java基础(6)--数组和方法

数组

1. 什么是数组？

数组是相同数据类型的元素组成的集合。这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。（“一个跟着一个”）。

2. 数组变量数组对象  数组元素

数组变量：是引用数组的变量，是引用变量。

数组（数组对象）：数组整体对象

数组元素：数组中每个元素

羊村的全体羊，他们打败了灰太狼。 他们 和 羊村的全体羊 之间是引用的关系，他们是变量，他们相当于 数组变量；羊村的全体羊相当于 数组（数组对象）；喜洋洋是数组元素

3.数组的声明：

int[] arr;
int arr[]; //不常用，很少使用

int[] 是数组类型，是引用类型。int[]表示数组中的每一个元素都是int类型。arr是变量(引用变量)，类型是数组类型int[]。

int[] arr=new int[10];new int[10]是创建数组对象，将对象的引用赋值给ary变量。ary变量就引用了数组对象，这个对象有10个元素。10表示数组的长度，即数组中元素的个数。

java数组元素是自动初始化的，初始化为零值。有： 0  0.0  \u0000  null false

int[]  arr=new int[10],创建数组对象，有10个元素，每个元素的初始值是0；

double[] arr=new double[3],数组对象有3个元素，每个元素的初始值是0.0；

char[] arr=new char[3],每个元素的初始值是\u0000；\u0000--\ufffff，\u开头的是一个Unicode码的字符，　\u0000字符是数值0对应的字符

boolean[] arr=new boolean[3],,每个元素的初始值是false；

4. 数组对象的创建和初始化

动态初始化

1）new 类型[长度]    new int[4]　　　　类型是任何类型：基本类型、类类型(String，Integer)　　长度：变量或常量 值：0 ~ Integer.MAX_VALUE

2）new 类型[]{元素0，元素1，元素2}　　直接给出元素，元素直接初始化，元素的长度就是长度。

静态初始化　　

类型[] 变量={元素0，元素1，元素2}。这种方式可以看做是 new int[]{4,5,6} 的简化版。只能用于声明时的初始化，不能用于赋值。

注意

new int[length] 适合创建不知道具体的元素，数量很多。new int[]{2,3,4} 适合已经知道具体元素了，元素比较少。{4,5,6} 只是适合知道元素，并只能使用在声明变量直接初始化。

5. 数组的访问

数组一旦创建后，数组的长度是不可以改变的。

调用数组的length属性可以获取数组的长度；int len=arr.length

可以通过下标的方式访问数组中的每一个元素。注意：数组的下标从0开始，对于长度为n的数组，下标的范围是0~n-1。

数组不能越界访问，会出现运行异常。

迭代数组元素,迭代数组,也称为遍历数组,就是逐一处理元素

for(int i=0; i<ary.length; i++){
    // i = 0 1 ... ary.length-1
    System.out.println(ary[i]);
}

案列 

学生成绩管理

数据模型设计

names = { "Tom", "Jerry", "Andy", "John" }

score = {  85  ,      67,    66,     98  }

0          1       2       3

算法设计，业务功能实现

1. 成绩输入。 　迭代显示每个人名，从控制台读取数据填充到对应的分数数组

2. 成绩列表, 并计算平均成绩。　　迭代每个人名，并且显示对应的成绩，统计总分。最后计算显示平均分。

3. 查询某人的成绩。　　等待输入查询人名，根据人名迭代找人名，如果找到就显示人名和对应的成绩。

public static void main(String[] args) {

        String[] names = {"Tom", "Jerry", "Andy", "John"};
        int[] score = new int[names.length];
        // 处理控制台命令
        Scanner in = new Scanner(System.in);
        System.out.println("\t欢迎使用成绩管理");
        while(true){
            System.out.print("1.成绩录入  2.成绩单  3.查询  0.离开, 选择:");
            String cmd = in.nextLine();// 从控制台读取一行字符串
            // 比较字符串必须使用equals()方法！最后是字符串字面量与对象比较
            if("0".equals(cmd)){
                System.out.println("亲，再见了(T_T)!");
                break;
            }
            else if("1".equals(cmd)){// cmd command 命令
                // 输入
                System.out.println("开始输入成绩");
                for(int i = 0; i < names.length; i++){
                    String name = names[i];// name 代表每个人名
                    System.out.print((i + 1) + " 输入 " + name + " 的成绩：");
                    String str = in.nextLine();// "95"
                    // parseInt 将10进制的字符串转换为整数
                    score[i] = Integer.parseInt(str);// "95" -> 95(int)
                }
            }
            else if("2".equals(cmd)){
                // 成绩单
                int sum = 0;
                for(int i = 0; i < names.length; i++){
                    String name = names[i];
                    System.out.println((i + 1) + "." + name + "的成绩:" + score[i]);
                    sum += score[i];
                }
                System.out.println("平均成绩：" + (sum / names.length));
            }
            else if("3".equals(cmd)){
                // 3.查询
                System.out.print("输入查询人名：");
                String name = in.nextLine();
                for(int i = 0; i < names.length; i++){
                    if(name.equals(names[i])){
                        System.out.println((i + 1) + "." + name + "的成绩:" + score[i]);
                        break;
                    }
                }
            }
            else{
                System.out.println("命令错啦!");
            }
        }
 }

Arrays中常用的方法

JDK中的java.utils.Arrays类提供对数组操作的一系列使用方法。使用API方法：API方法封装了常用算法功能，使用这些功能简化开发过程， 提高开发效率。API 封装的算法也是 for if 实现的，也可以不用。

如：使用toString可以便捷输出数组内容，使用equals可以便捷比较 数组内容。

数组类型是引用类型，但是没有覆盖object中的toString ，equals方法。所以要输出比较用Arrays工具类的toString方法，equals方法

Arrays.toString方法

用于字符串表示数组的元素。将数组的内容连接成一个字符串。

String[] str={"Tom", "Andy", "Jerry", "John"};
Arrays.toString(str);--->"[Tom, Andy, Jerry, John]"

Arrays.equals方法

用于比较两个数组的各个元素是否相等。

char[] answer = {'A', 'C', 'D'};
char[] input = {'A', 'C', 'D'};
boolean match = Arrays.equals(answer, input);//true

Arrays.sort方法

用于实现数组的排序。

int[] score = {67, 49, 88, 69, 95};
Arrays.sort(score);//小 -> 大  [49 67 69 88 95]
String[] names = {"Tom", "Jerry", "Andy", "John"};
Arrays.sort(names);//按字典顺序排序  [Andy  Jerry  John  Tom]

Arrays.fill();

填充数组

String[] names=new String[3];
Arrays.fill(names,”aa”);
Arrays.toString(names)//[aa, aa, aa]

Arrays.binarySearch方法

用于实现有序数组的二分法查找。二分查找，在未排序的数组上二分查找结果是不稳定的。在查找之前必须先排序。

String[] names={"Tom","Andy","Jerry","John","Wang"，”Andy”};
Arrays.sort(names);// 先排序
int index = Arrays.binarySearch(names,"Jerry");返回下标值
index = Arrays.binarySearch(names,"Lee");// 找不到时，返回负数
index = Arrays.binarySearch(names,"Andy");//有多个相等元素时不确定返回的是哪一个。

数组的复制和赋值

数组的赋值

ary1和ary2都指向同一个数组对象，ary1和ary2相互影响。

int[] ary1 = {4,5,6};
int[] ary2 = ary1;
ary2[1]++;

数组的复制

就是将一个数组（源数组）中的各个元素值复制到另外一个数组（目标数组）中。

1. 使用for循环实现

int[] ary3 = new int[ary1.length];
for(int i=0; i<ary1.length; i++){
    ary3[i] = ary1[i];
}
ary3[1]++;

2. 使用API System.arraycopy().

System.arraycopy 是用C代码实现。System.arraycopy(src, srcPos, dest, destPos, length)

src-----要复制的源数组

srcPos--从源数组复制的起始位置

dest----复制到的目标数组

destPos-复制到目标数组的起始位置

length--要复制的元素的个数

int[] ary4 = new int[ary1.length];

System.arraycopy(ary1, 0, ary4, 0, ary1.length);

3. 使用Array.copyOf()

Arrays.copyOf() 方法，底层就是arraycopy

int[] ary5 = Arrays.copyOf(ary1, ary1.length); ary5：复制后的数组　　ary1：原数组　　ary1.length复制后的长度

数组的扩展

数组的长度在创建后不可改变的。所谓的扩展是指创建一个更大新数组并将原有数组的内容复制到其中。利用复制并更换数组对象，实现数组的变长计算。

1. System.arraycopy

String[] names={"Tom","Andy","Jerry","John","Wang"};
String[] names1=new String[names.length+1];
System.arraycopy(names, 0, names1, 0, names.length);
names1[names1.length-1]="liuyueqin";
System.out.println(Arrays.toString(names1));

2. Arrays.copyOf

String[] names={"Tom","Andy","Jerry","John","Wang"};
String[] names1=Arrays.copyOf(names, names.length+1);
names1[names1.length-1]="liuyueqin";
System.out.println(Arrays.toString(names1));

数组排序算法

选择排序

原理

1）将数组中的每个元素与第一个元素比较，如果这个元素小于第一个元素，则交换这两个元素。

2）循环第一条规则，找出最小元素，放于第一个位置。

3）经过n-1轮比较完成排序。

简单而言，每轮都找到最小的放到前面。

for(int i = 0; i < ary.length - 1; i++){
            for(int j = i; j < ary.length; j++){
                if(ary[i] > ary[j]){
                    int temp = ary[i];
                    ary[i] = ary[j];
                    ary[j] = temp;
                }
            }
}

冒泡排序

原理

1）逐一比较数组中相邻的两个元素, 如果后面的数字小于前面的数字,就交换先后元素。

2）经过一个轮次的比较, 一定有一个最大的排在最后的位置.

3）每次比较剩下的元素, 经过n-1次比较, 可以实现排序

简单说: 比较相邻元素,大的向后交换。

for(int i = 0; i < ary.length; i++){
            for(int j = 0; j < ary.length - i - 1; j++){
                if(ary[j] > ary[j + 1]){
                    int temp = ary[j];
                    ary[j] = ary[j + 1];
                    ary[j + 1] = temp;
                }
            }
 }

插入排序

原理

1）将数组分为两部分, 将后部分的第一张逐一与前部分每一张比较。

2）找到合理位置插入.

 int i,k,j;
 for(i=1;i<ary.length;i++){
           k=ary[i];
           for(j=i-1;j>0;j--){
                  f(k<ary[j]){
                         ary[j+1]=ary[j];
                  }else{
                         break;
                  }
           }
           ary[j+1]=k;
  }

系统排序

JDK提供的排序方法Arrays.sort(ary)的效率要比上面三种排序方法高。

int[] ary1 = new int[100000];
Random random = new Random();
for(int i = 0; i < ary1.length; i++){
    ary1[i] = random.nextInt();
}
long time1 = System.currentTimeMillis();
Arrays.sort(ary1);
long time2 = System.currentTimeMillis();
System.out.println(time2 - time1);