接上章 数组

chp4 数组

一次性定义多个同类型的变量

数组的定义  int[] a;  int []a;  int a[];

为数组分配空间  a = new int[10];

                数组元素具有默认值

 默认值规则:

1.数值类型  0   

2.布尔类型  false

3.对象类型  null

访问数组元素：a[0]a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 

              数组名[下标]

数组的显式初始化

     a = newint[]{2,1,6,5,8};  

     a=newint[5]{2,1,6,5,8}； // error!

        int[] a = {2,1,6,5,8};

数组名.length:   数组的长度

 

数组下标从0开始:

a[0]:1000         a[1]:1000

a[1]:1004         a[2]:1004

a[2]:1008         a[3]:1008

a[i]:1000+4*i      a[i]:1000+4*(i-1)

增强for循环

for(声明语句 : 表达式) { //代码句子 }

publicclass Test {

publicstatic void main(String args[]){

 int [] numbers = {10, 20, 30, 40, 50};

 for(int x : numbers ){

System.out.print(x );

System.out.print(",");

}

System.out.print("\n");

String[] names ={"James", "Larry", "Tom","Lacy"};

 for( String name : names ) {

 System.out.print( name ); System.out.print(",");

}

}

}

数组的遍历：访问到数组中的每一个元素。并且可以对每一个元素进行一系列的操作：

  方法一：循环遍历：

for(int i=0;i<a.length;i++){
    System.out.print(a[i]+"");//i表示下标
}

方法二：for-each遍历

        for (int i : a){
            i++;//数组中每一个数加一。
    System.out.print(i+" ");//表示数组中的每一个内存单元。
       }

方法二可以不用去理解，他就相当于方法一的简化写法，但是两者都有一定的区别：方法一可以控制遍历的区间和步长，而方法二只能将所有的元素都进行遍历。

 

publicclass TestArray {

 public static void main(String[] args) {

 double[] myList = {1.9, 2.9, 3.4, 3.5};

//打印所有数组元素

for(int i = 0; i < myList.length; i++) {

 System.out.println(myList[i] + " ");

 }

//计算所有元素的总和

doubletotal = 0;

for(int i = 0; i < myList.length; i++) {

 total += myList[i];

}

System.out.println("Totalis " + total);

//查找最大元素

doublemax = myList[0];

for(int i = 1; i < myList.length; i++) {

if(myList[i] > max) max = myList[i];

 }

System.out.println("Maxis " + max);

}

}

数组的本质：一串连续内存的空间。

package第5章_数组;

import java.util.Scanner;

public class S201_05_03_计算方差 {
    public static void main(String[]args) {

        Scanner sc = newScanner(System.in);
        System.out.println("请输入五个数：");
        /*int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        int num3 = sc.nextInt();
        int num4 = sc.nextInt();
        int num5 = sc.nextInt();
        double avg =(num1+num2+num3+num4+num5)/5;
        double variance=((num1-avg)*(num1-avg)+(num2-avg)*(num2-avg)+(num3-avg)*(num3-avg)+(num4-avg)*(num4-avg)+(num5-avg)*(num5-avg))/5;
        System.out.println(variance);*/
        int [] a=new int[5];
        /*a[0]=sc.nextInt();
        a[1]=sc.nextInt();
        a[2]=sc.nextInt();
        a[3]=sc.nextInt();
        a[4]=sc.nextInt();*/
        int sum=0;
        for (inti=0;i<=a.length-1;i++){
            a[i]=sc.nextInt();
            sum+=a[i];
        }
        double avg= sum/5.0;
        double variance=0;
        for (int i=0;i<=a.length-1;i++){
           variance+=(a[i]-avg)*(a[i]-avg)/5.0;
        }
        System.out.println(variance);
    }
}

注掉的代码，那种方法十分死板，如果是十个数，一百个数，定义的变量会越来越多，代码会一直重复。

数组和循环的配合，可以使解题方法更为灵活，且不需要定义过多的变量。

 

常见的查找方法：

 第一种顺序查找，也就是按照顺序一位一位的查找。

 package 第5章_数组;

import java.util.Scanner;

public class S201_05_05_数组的查找 {
    public static void main(String[]args) {
        Scanner sc = newScanner(System.in);
        System.out.println("请输入需要查找的数为：");
        int num = sc.nextInt();
        int [] arr={2,4,6,8,10,12,14,16};
        int index=find(arr,num);
        if (index==-1) {
            System.out.println("没得找到");
        }else {
            System.out.println(index);
        }
    }
    public static int find(int [] arr,intnum){
        int count=0;
        for (int i: arr) {
            if (i==num){
                return count;
            }
            count++;
        }
        return -1;//表示没得找到
    }
}

弊端：数据量大的时候，在最差的情况下，计算机的负载也非常的大。效率低。

第二种：折半查找（二分查找）：优化了查找的效率。

privatestatic int find(int[] arr, int num) {
    int start=0;
    int end=arr.length-1;
    while (start<=end){
        int mid=(start+end)/2;//找到中间值
        if (arr[mid]==num){//num表示自己输入的值
            return mid;
        }
        if (arr[mid]>num){
            end=mid-1;
        }else {
            start=mid+1;
        }
    }
     return -1;//表示没有找到
}

 

弊端：必须对一个有序的数组进行查找。

 

数组的排序：

方法一：冒泡排序

package第5章_数组;

import 工具包.A201_01_04_数组的遍历;

public class S201_05_07_冒泡排序 extends A201_01_04_数组的遍历{
    public static void main(String[]args) {
        int [] arr ={5,3,2,4,1,8,9,7,0,6};
         sort(arr);
         write(arr);
    }

    private static void sort(int[] arr) {
        int temp = 0;
        for (int i = 0; i <arr.length; i++) {
            for (int j = 0; j <arr.length-1; j++) {
                if (arr[i] < arr[j]) {
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

 

方法二：选择排序    

package第5章_数组;
/*每一次从待排序的数据元素中选出最小（或最大）的一个元素，
存放在序列的起始位置，直到全部待排序的数据元素排完。
 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，
 导致第一个5挪动到第二个5后面）。
 用第一个数与后面的每一个数作比较，发现比他小的后交换位置*/
public class S201_05_08_选择排序 {
    public static void main(String[]args) {
        int [] arr ={5,3,2,4,1,8,9,7,0,6};
        sort(arr);
    }
    private static void sort(int[] arr) {
        for(int i = 0; i < arr.length- 1; i++) {// 做第i趟排序
                int k = i;
            for(int j = i + 1; j <arr.length; j++){// 选最小的记录
                if(arr[k] > arr[j]){
                    k = j; //记下目前找的最小值到所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+"");
        }
    }
}

数组的优缺点(线性表)   存储空间连续

优点: 查询效率高,寻址快

缺点: 长度固定,不可改变,

      元素插入和删除效率低 

链表的优缺点: 存储空间不连续

优点:长度可变, 元素插入和删除效率高

缺点:查询效率低

 

二维数组  一维数组的一维数组

 

冒泡排序 : 相邻的元素比较,每次找出最大的数

选择排序 : 第一个元素和剩余所有元素比较,每次找出最小的数

二分搜索法: 在一个排好序的数组中,从中间元素开始查找,并快速定位

二维数组的长度：数组名.length ---每个一维数组：数组名[下标].length

二维数组的遍历---两重for循环

for(inti = 0; i < arr.length; i++){ //遍历二维数组，遍历出来的每一个元素是一个一维数组for(int j =0; j < arr[i].length; j++){ //遍历对应位置上的一维数组

System.out.println(arr[i][j]);

}

}

二维数组的反转---头尾交换

for(intstart = 0, end = arr.length -1; start < end; start++,end--){int[] temp =arr[start];

arr[start]= arr[end];

arr[end]= temp;

}