JavaSE第六章：数组

Java第六章：数组

一维数组

数组使用和注意细节

1.
    int a[] = new int[3];
2.
    int a[];
	a = new int[3];
3.
    int a[] = {1,2,3,4};
4.
    int a[] = new int[]{1,2,3}
注意细节：
1.数组创建后，若没有赋值，则有默认值：int、short、byte、long->0
    							float、double->0.0
    							char->\u0000
  								boolean->false
    							String->null
2.数组属引用类型，数组型数据是对象(object)

数组赋值机制

1.值传递：
	传递的是值的拷贝
2.引用传递：
	传递的是地址的拷贝

数组拷贝

for循环拷贝

public class copy {
    public static void main(String[] args) {
        int[] a = new int[3];
        for(int i = 0;i < a.length;i++){//为数组a赋值
            a[i] = i;
        }
        int[] b = new int[3];
        for(int i = 0;i < a.length;i++){//b数组拷贝a数组
            b[i] = a[i];
        }
        for(int i = 0;i < b.length;i++){//输出b数组
            System.out.print(b[i]+" ");
        }
    }
}

数组反转

1.找规律进行反转

2.逆序赋值方式

import javax.rmi.ssl.SslRMIClientSocketFactory;

class fanzhuan {
    public static void main(String [] args){
        /*
        需求：找规律进行反转
        实现：(1):需反转(len/2)次
             (2):进行交换的两个元素下标相加为len-1
         */
        //代码实现：
        int[] a = new int[6];
        int temp = 0;
        int len = a.length;
        for(int i = 0;i < len;i++){//为数组a赋值
            a[i] = i;
        }
        for(int i = 0;i < len;i++){//输出a数组
            System.out.print(a[i]+" ");
        }
        System.out.println();
        for(int i = 0;i<len/2;i++){
            temp = a[i];
            a[i] = a[len-1-i];
            a[len-1-i] = temp;
        }
        for(int i = 0;i < len;i++){//输出反转后的a数组
            System.out.print(a[i]+" ");
        }
        System.out.println();
        /*
        需求：逆序赋值方式
        实现：(1):创建arrNew数组，逆序遍历arr数组拷贝至arrNew数组
             (2):将arrNew数组赋值给arr数组
         */
        //代码实现：
        int[] arr = new int[10];
        int[] arrNew = new int[10];
        for(int i = 0;i < arr.length;i++){//为arr数组赋值
            arr[i] = i;
        }
        for(int i = 0;i < arr.length;i++){//输出arr数组
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        for(int i = arr.length-1,j = 0;i >= 0;i--,j++){//逆序遍历arr数组并为arrNew数组赋值
            arrNew[j] = arr[i];
        }
        arr = arrNew;
        for(int i = 0;i < arr.length;i++){//输出arr数组
            System.out.print(arr[i]+" ");
        }
    }
}

数组扩容

import java.util.Scanner;
class kuorong {
    public static void main(String[] args){
        /*
        需求：数组扩容
        实现：创建一个length+1的数组，并进行数组拷贝，并为新数组最后一个元素赋值，再将新数组赋值给旧数组
         */
        int[] arr = new int[3];
        for(int i = 0;i < arr.length;i++){//为arr数组赋值
            arr[i] = i;
        }
        int num;
        String t;
        do{
            Scanner reader = new Scanner(System.in);
            int[] arrNew = new int[arr.length+1];
            System.out.print("请输入要扩容的数：");
            num = reader.nextInt();
            arrNew[arrNew.length-1] = num;
            for(int i = 0;i < arr.length;i++){//拷贝arr数组至arrNew数组
                arrNew[i] = arr[i];
            }
            arr = arrNew;
            for(int i = 0;i < arr.length;i++){//输出扩容后的数组
                System.out.print(arr[i]+" ");
            }
            System.out.println();
            System.out.println("请输入是否继续扩容 y/n");
            t = reader.next();
            if(t.equals("n")){
                break;
            }
        }while(true);
    }
}

数组缩减

import java.util.Scanner;
class suojian {
    public static void main(String[] args){
        /*
        需求：数组缩减
        实现：(1):创建一个arr.lenth-1的arrNew数组，然后拷贝arr除最后一个元素，然后将arrNew赋值给arr
             (2):判断arr.lenth，若大于1，则询问是否继续缩减，否则输出长度为1，不可继续缩减
         */
        //代码实现
        int arr[] = new int[3];
        for(int i = 0;i < arr.length; i++){//为arr数组进行赋值
            arr[i] = i;
        }
        do{//循环进行缩减数组
            for(int i = 0;i < arr.length; i++){//将arr数组进行输出
                System.out.print(arr[i] + " ");
            }
            Scanner reader = new Scanner(System.in);
            int arrNew[] = new int[arr.length-1];
            char s;
            if(arr.length > 1){//长度是否>1决定走哪个分支
                while(true){//循环询问是否继续缩减元素
                    System.out.println("\n是否继续缩减数组元素(y/n):");
                    s = reader.next().charAt(0);
                    if(s == 'y'){
                        break;
                    }else if (s == 'n'){
                        return;
                    }else{
                        System.out.println("您的输入有误，请重新输入;");
                    }
                }
            }else{
                System.out.println("数组长度为1，不可再缩减;");
                return;
            }
            for(int i = 0;i < arr.length - 1; i++){//拷贝arr除最后一个元素到arrNew
                arrNew[i] = arr[i];
            }
            arr = arrNew;
        }while (true);
    }
}

数组排序

介绍：

1.内部排序：
	指将需要处理的所有数据都加载到内存中进行排序
2.外部排序：
	数据量过大，无法全部加载到内存中，需要借助外存进行排序(合并排序法和直接合并排序法)

冒泡排序

class BubbleSort {
    public static void main(String args[]){
        int[] arr = {20,13,24,23,4};
        int temp = 0;
        for(int i = 0;i < arr.length-1;i++){
            for(int j = 0;j < arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

数组查找

1.顺序查找

2.二分查找

import java.lang.Math;
import java.util.Scanner;

class chazhao {
    public static void main(String[] args){
        /*
        需求：1.顺序查找
             2.二分查找
         */
        //1.代码实现：
        Scanner reader = new Scanner(System.in);
        int[] arr = new int [10];
        int[] arr1 = new int[1];
        int  count = 0;
        for(int i = 0;i < arr.length;i++){//为arr数组赋1到100随机数
            arr[i] = (int)(Math.random()*100)+1;
        }
        for(int i = 0;i < arr.length;i++){//输出arr数组
            System.out.print(arr[i]+" ");
        }
        for(int i = 0;i < arr.length;i++){//循环顺序查找
            if(arr[i] == 8){
                System.out.println("已找到数据8，该索引为:"+i);
                count++;
                arr1 = kuorong(i,arr1,count);
            }
        }
        if(count == 0){
            System.out.println("没找到");
        }
        //2.代码实现
        int[] a = {1,2,3,5,8,9,15,65};
        int start = 0;
        int end = a.length-1;
        //输入你要查找的数字
        System.out.println("请输入你要查找的数字:");
        int temp = reader.nextInt();
        //开始二分查找
        int index = middleSearch(a,start,end,temp);
        //根据返回的Index进行判断
        if(index == -1){
            System.out.println("未找到");
        }else{
            System.out.println("已找到你的数字,他的索引位置为:" + index);
        }
    }
    //二分查找(递归查找)方法
    static int middleSearch(int[] a,int start,int end,int temp){
        Scanner reader = new Scanner(System.in);
        int middle = (start + end) / 2;
        int count = 0;
        if(a[middle] == temp){
            //System.out.println("已找到你的数字,他的索引位置为:" + middle);
            return middle;
        }else if(a[middle] < temp){
            start = middle + 1;
        }else{
            end = middle - 1;
        }
        if(start > end){
            return -1;
        }
        return middleSearch(a,start,end,temp);
    }
    static int[] kuorong(int n1,int[] arr,int count){//数组扩容接口
        if(count == 1){
            arr[0] = n1;
            return arr;
        }
        else{
            int[] arrNew = new int[arr.length+1];
            arrNew[arrNew.length-1] = n1;
            for(int i = 0;i < arr.length;i++){//拷贝arr数组至arrNew数组
                arrNew[i] = arr[i];
            }
            arr = arrNew;
            for(int i = 0;i < arr.length;i++){//输出扩容后的数组
                System.out.print(arr[i]+" ");
            }
            System.out.println();
            return arr;
        }
    }
}

多维数组

二维数组使用和注意细节

1.
int a[][] = new int[2][3];
2.
int a[][];
a = new int[2][3];
3.
int a[][] = {{1,2},{3},{2,3,4,5}};
4.
int a[][] = new int[2][];//动态初始化-列数不确定
a[0] = new int[3];
a[1] = new int[4];

练习

杨辉三角

class TwoDimentional_yanghui {
    public static void main(String[] args){
        int arr[][] = new int[10][];
        for(int i = 0;i < arr.length;i++){
            arr[i] = new int[i+1];//给每个一维数组开辟空间
            for(int j = 0;j < arr[i].length;j++){//给每个一维数组赋值
                if(j==0||j==arr[i].length-1){//每一行的第一个和最后一个元素是1
                    arr[i][j] = 1;
                }
                else{//中间的元素
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }
        for(int i = 0;i < arr.length;i++){//输出杨辉三角
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}

本章作业

1.已知有个升序的数组，要求可以一个一个元素地插入，该数组顺序依然是升序。

import java.util.Scanner;
public class zuoye1 {
    public static void main(String[] args){
        /*
        需求：已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序
        实现：(1):找到要插入的索引位置
             (2):创建一个新数组，拷贝旧数组(跳过要插入的位置)
             (3):插入新元素
             (4):循环插入新元素
         */
        //代码实现
        Scanner reader = new Scanner(System.in);
        int arr[] = {1,5,6,8,9,15,18};
        int num;
        int index = -1;//用来判断有没有找到索引位置
        while(true){
            System.out.println("\n============原数组:");
            //将原数组进行输出
            for(int i = 0;i < arr.length; i++){
                System.out.print(arr[i] + " ");
            }
            System.out.println("\n请输入你要插入的元素:");
            num = reader.nextInt();
            //（1）找要插入的索引位置
            System.out.println("arr数组长度:"+arr.length);
            for(int i = 0;i < arr.length; i++){
                if(num <= arr[i]){
                    index = i;
                    break;
                }
                if(index == -1){
                    index = arr.length;
                }
            }
            //（2）创建一个新数组，拷贝旧数组(跳过要插入的位置)
            int arrNew[] = new int[arr.length + 1];
            int lenNew = arrNew.length;
            for(int i = 0,j = 0;i < lenNew; i++){//变量i控制arrNew下标,变量j控制arr下标.
                if(i == index){
                    System.out.println("要插入的索引位置为:"+index);
                    arrNew[index] = num;//(3)插入新元素
                }else{
                    arrNew[i] = arr[j];
                    j++;
                }
            }
            index = -1;//重置index方便后面判断
            arr = arrNew;
            //输出新数组
            System.out.println("===========新数组:");
            for(int i = 0;i < arr.length; i++){
                System.out.print(arr[i] + " ");
            }

        }
    }
}