1. 技术文章
  2. Java基础--day09

Java基础--day09

由 烂漫一生 提交于 2020-03-20 10:32:12

一维数组

单个的数组变量可以引用一个大的数据集合

1. 基础知识

一旦数组被创建，它的大小是固定的，使用一个数组引用变量，通过下标来访问数组中的元素

1.1 声明数组变量

elementType[] arrayRefVar; (元素类型[] 数组引用变量;)
e.g
    double[] mylist;

声明数组不在内存中分配空间，它只是创建一个对数组的引用的存储位置

1.2 创建数组

arrayRefVar = new elementType[arraySize];
  • [x] 使用new elementType[arraySize]创建一个数组
  • [x] 把新创建的数组的引用赋值给变量arrayRefVar

声明一个数组变量、创建数组、然后将数组引用赋值给变量这三个步骤可以合并成一条：

elementType[] arrayRefVar = new elementType[arraySize];
元素类型[] 数组引用变量 = new 元素类型[数组大小]
double[] myList = new double[10];

赋值为：

arrayRefVar[index] = value;

在java中，数组变量时一种引用，如myList是一个含有10个double型元素数组的引用变量

1.3 数组大小和默认值

在分配数组时候，必须指定该数组能够存储的元素个数。创建数组之后，就不能再修改它的大小。可以使用arrayRefVar.length得到数组大小。

当创建数组后，它的元素被赋予默认值。数值型基本数据类型的默认值为0，char型的默认值为'\u0000'，boolean型的默认值为false

1.4 访问数组元素

通过下标从0到length - 1来访问数组

arrayRefVar[index]; (数组引用变量[下标];)

1.5 数组初始化

elementType[] arrayRefVar = {value0, value1, ..., valuek};

数组初始化必须像上面语法一样，包含声明数组 ，创建数组，初始化数组 结合在一条语句中，此时数组含有k个元素，从0到k-1。 数组初始化语法中不使用操作符 new

1.6 处理数组

经常使用for循环

  1. 数组中所有元素都是同一个类型
  2. 数组大小已知

对于char[]类型的数组，可以使用一条打印语句打印

char[] iloveu = {'I', ' ', 'L', 'o', 'v', 'e', ' ', 'U'};
System.out.println(iloveu);

应用

随机打乱（shuffling)

for(int j = myList.length - 1; j > 0; j--){
    int k = (int)(Math.random() * (i + 1));
    double temp = myList[i];
    myList[i] = myList[k];
    myList[k] = temp;
}

移动元素

double temp = mylist[0];
for(int i = 1; i < mylist.length; i++){
    mylist[i - 1] = mylist[i];
}
mylist[mylist.length - 1] = temp;

简化编码

String[] months = {"Jan", "Feb", ..., "Dec"};
System.out.print("Enter a month nunber:");
int monthNumber = input.nextIn();
System.out.println("The month is" + months[monthNumber - 1]);

1.7 foreach循环

对于foreach循环，可以不使用下标变量就可以顺序地遍历整个数组

for(double e: myList){
    System.out.println(e);
}

1.8 练习题

1.8.1 分析数字

找到大于所有项平均值的那些项

import java.util.Scanner;
public class AnalyzeNumber {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] str = new int[10];
        System.out.println("Enter 10 numbers:");
        int total = 0;
        for (int j = 0; j < str.length; j++) {
            str[j] = input.nextInt();
            total += str[j];
        }
        int average = total / str.length;
        String remembers = "";
        for(int j = 0; j < str.length; j++){
            if (str[j] > average){
                remembers += str[j] + " ";
            }
        }
        System.out.print("大于" + average + "的数有");
        System.out.println(remembers);
    }
}

结果

Enter 10 numbers:
1 2 3 4 5 6 7 8 9 10
大于5的数有6 7 8 9 10

1.8.2 一副牌

从一副牌中随处选出4张，判断花色和牌号

public class DeckOfCards {
    public static void main(String[] args) {
        String[] color = {"黑桃", "红桃", "方块", "梅花"};
        String[] number = {"A", "2", "3", "4", "5", "6", "7", "8", "9",
        "10", "J", "Q", "K"};
        int[] deck = new int[52];
        for(int j = 0; j < deck.length; j++){
            deck[j] = j;                        // 初始化，从0到51共52张牌
        }
        // 打乱排序
        for(int j = 0; j < deck.length; j++){
            int site = (int)(Math.random() * deck.length);
            int temp = deck[j];
            deck[j] = deck[site];
            deck[site] = temp;
        }
        //
        for ( int i = 0 ; i < 4 ; i++) {
            String suit = color [ deck [ i ] / 13 ] ;
            String rank = number [ deck [ i ] % 13 ] ;
            System . out . println (deck[i] + "号牌是：" + suit + " " + rank) ;
            }

    }
}

结果

12号牌是：黑桃 K
46号牌是：梅花 8
40号牌是：梅花 2
4号牌是：黑桃 5

1.9 数组的复制

要将一个数组中的内容复制到另一个中，需要将数组的每一个元素复制到另一个数组中，不能直接使用语句list2 = list1，这是非常严重的错误，会导致list2原先所引用的数组不能再引用。

复制数组的三种方法：

  • 使用循环语句逐个
int[] sourceArray = {2, 3, 4, 5};
int[] targetArray = new int[sourceArray.length];
for(int i = 0; i < sourceArray.length; i++){
    targetArray[i] = sourceArray[i];
}
  • 使用System类中的静态方法arraycopy
arraycopy(源数组，源数组起始位置，目标数组，目标数组起始位置，复制长度);
e.g
    System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);

arraycopy方法没有给目标数组分配内存空间，复制前必须创建目标数组以及分配给它的内存空间。复制完成后，sourceArray和targetArray具有相同的内容，但是占有独立的内存空间。

  • 使用clone方法复制数组

2.数组与方法

2.1 将数组传递给方法

当将一个数组传递给方法时，数组的引用被传给方法

public static void printArray(int[] array){
    for(int i = 0; i < array.length; i++){
        System.out.print(array[i] + " ");
    }
}

调用如下：

printArray(new int[]{3, 1, 2});

像上面这样创建的数组叫做匿名数组，创建语句为new elementType[]{value0, value1, ..., valuek}

Java使用按值传递的方式将实参传递给方法。传递基本数据类型变量的值和传递数组值大有不同：

  • 对于基本数据类型参数，传递的是实参的值
  • 对于数组类型参数，参数值是数组的引用

2.2 从方法中返回数组

当从方法中返回一个数组时，数组的引用被返回

如下面，返回一个与输入数组元素顺序相反的数组：

public static int[] reverse(int[] list){
    int[] result = new[list.length - 1];
    for(int i = 0, j = list.length - 1; i < list.length; i++, j--){
        result[j] = list[i];
    }
    return result;
}
int[] list1 = {1, 2, 3};
int[] list2 = reverse(list1)

2.3 实例： 统计每个字母出现的次数

利用hash表来统计字母出现次数

public class CountLettersInArray {
    public static void main(String[] args) {
        char[] myString = new char[100];
        int[]  myCount = new int[26];
        myCount = getArray(myString);
        printTable(myString, myCount);
    }
    // 返回随机字符
    public static char getRandomLetter(char ch1, char ch2){
        return (char)(ch1 + (Math.random() * (ch2 - ch1 + 1)));
    }

    public static int[] getArray(char[] string){
        int[] count = new int[26];
        for (int i = 0; i < string.length; i++){
            string[i] = getRandomLetter('a', 'z');
            count[string[i] - 'a'] ++;
        }
        return count;
    }
    // 打印输出
    public static void printTable(char[] string, int[] count){
        System.out.print("100 个字母如下");
        for(int i = 0; i < string.length; i++){
            if (i % 20 == 0)System.out.println();
            System.out.print(string[i] + " ");
        }
        System.out.print("\n26 个字母出现的次数");
        for(int i = 0; i < 26; i++){
            if (i % 10 == 0)System.out.println();
            System.out.print(count[i] + " " + (char)('a' + i) + " ");
        }
    }
}

结果：

100 个字母如下
i u k g a l f d s u q z l n z o w e k m 
c r o d q q e s l f l r c y j v m q v a 
g o v z n y t n a v m i b q o t i o r o 
m h l g d q m n t j j z h x c a g m l k 
r k d q z z p q m u c i z w h u s n y s 
26 个字母出现的次数
4 a 1 b 4 c 4 d 2 e 2 f 4 g 3 h 4 i 3 j 
4 k 6 l 7 m 5 n 6 o 1 p 8 q 4 r 4 s 3 t 
4 u 4 v 2 w 1 x 3 y 7 z

3. 可变长参数列表

具有同样类型的可变长度的参数可以传递给方法，并将作为数组对待

方法中的参数声明如下

typeName... parameterName(类型名...参数名)
  • 指定类型后面紧跟省略号
  • 一个方法只能指定一个可变长度参数
  • 任何常规参数必须放在可变长参数前面
public class VarArgsDemo{
    public static void main(String[] args){
        printMax(34, 3, 3, 2, 56.2);
        printMax(new double[]{1, 2, 3});
    }
    public static void printMax(double... numbers){
        if(number.length == 0){
            System.out.println("NO argument passed");
            return;
        }
        double result = number[0];
        for(int i = 1; i < numbers.length; i++){
            if(numbers[i] > result)
                result = numbers[i];
        }
        System.out.println("The max value is " + result);
    }
}

Write by Gqq

标签
string
char
数组
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!