JAVA 数组第六天

一、数组

1.1、什么是数组

所谓数组，是有序的元素序列。  若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。

数组的分类

一维数组，二维数组，三维数组，多维数组。。。。。。（一维数组使用较多，二维数组偶尔使用！）

1.2、数组的特点（一维数组）

js数组：1.没有数据类型限制,2.可以随意扩容。
java中的数组：同一数据类型的一组数 也有下标 数组一但开辟大小就不能更改 而且必须定义好数据类型 内存的空间是连续的

数组是引用数据类型 （可以存储基本数据类型，也可以存储引用数据类型）
数据类型统一
长度固定
java的数组的父类是Object
数组不是开辟内存存储是
数组不是直接存储对象的 是存储对象的引用（内存地址）
数组属性的默认值
整数类型：0

浮点型：0.0

字符型：“\u000”

布尔型：false

引用类型：null

数组的扩容
因为数组是定长的，如果想扩容只能创建一个新的数组

public static void main(String[] args) {
        int[] arrs= new int[]{1,2,3,4,5};
       int [] temp =new int[arrs.length+1];//此时只是把长度给他了内容没有给

        for(int i=0;i<arrs.length;i++){
            temp[i]=arrs[i];//把数组arrs循环付过去
        }
       for(int i:temp){
           System.out.println(i);
       }
       arrs=temp;//把临时数组赋值给原数组，这时原数组已经扩容把临时数组赋值给原数组，这时原数组已经扩容
        System.out.println(arrs[5]);
    
    }

int[] arr2=java.util.Arrays.copyOf(原数组名，新数组长度);

 int[] arrs= new int[]{1,2,3,4,5};
        int [] arrs2= Arrays.copyOf(arrs,arrs.length+1);
        for (int i:arrs2
             ) {
            System.out.print(i);

        }

二、数组的使用

2.1、数组的定义

数组定义的格式：

//定义有容量的数组
数据类型[] 数组名字 = new 数据类型[数组容量];
//定义有初始化数据的数组
数据类型[] 数组名字 = new 数据类型[]{数据1,数据2,数据3,数据4...};
//简化版定义数组
数据类型[] 数组名字 = {数据1,数据2,数据3,数据4...};
数据类型 数组名字[]={数据1，数据2，数据3}

2.2、数组的操作和注意事项

求数组下标

    int[] scores={100,99,98,97,60,96};
        int index=-1;//初始值< 0   这个是求下标
        for(int i=0;i<scores.length;i++){
            if(scores[i]==60){
                index=i;//求60这个下标 等于60的时候退出循环 这个时候i就是下标 吧i给index 就给出下标了
                break;
            }
        }

数组scores插入61

//数组从后向 每一个数组的内容0向后移动一位 但是java的数组是固定长度的 使用就需要扩展新数组

 //数组从后向 每一个数组的内容0向后移动一位  但是java的数组是固定长度的 使用就需要扩展新数组
        //换数组 ----扩展数组---扩展出来的是一个新的数组 开辟一个新的内存
        scores = Arrays.copyOf(scores,scores.length+1);
        //原来数组的长度6  新的数组的长度是7  新的int数组默认值最后一个为0
        System.out.println(scores);
        for(int i:scores){
            System.out.print(i+"\t");
        }
                //从最后一个的下标开始向后移动移动到这个要添加的下标是停止
        for(int i=scores.length-1;i>index;i--){
            scores[i]=scores[i-1];//吧前一个的值给下一个下标就相当于向后移动了

        }
        System.out.println();
        System.out.println("=========================");
        scores[index]=61;
        for(int i:scores){
            System.out.print(i+"\t");
        }

删除60

 int[] scores={100,99,98,97,60,96};  
    int index=-1;//初始值< 0   这个是求下标
        for(int i=0;i<scores.length;i++){
            if(scores[i]==60){
                index=i;//求60这个下标 等于60的时候退出循环 这个时候i就是下标 吧i给index 就给出下标了
                break;
            }
        }
        for(int i=index;i<scores.length-1;i++){
            scores[i]=scores[i+1];
        }//长度减一
        scores=Arrays.copyOf(scores,scores.length-1);
        for(int i:scores){
            System.out.print(i+"\t");
        }

2.2.1、数组的内存

数组是存储在 堆内存里面的 对象也是
java数组是非常占用内存的 ， 每一次增加 和减少 但是添加

数组在内存存储方面 数组中元素的内存地址是连续的（存储的每一个元素都是有规则的挨着排列着的（特色））

数组是一种简单的数据结构

2.2.2、数组的长度

数组名.length

 int[] j={4,45,6,7,};
        System.out.println(j.length);//4
 j=new int[9]; //这个时候是一个新的数组了  引用地址变了  以前的也没有消失等待内存释放Gc机制
        System.out.println(j.length+","+j[1]);

2.2.3、数组的遍历

数组的循环遍历

  String strs[]=new String[]{"df","sd","sd"};
  
        for (int i=0;i<strs.length;i++){
            String temp =strs[i];
            System.out.print(temp+" ");
        }
        System.out.println("");
        //for(数据类型  变量名：遍历的数组名){}
        for(String aa:strs){
            System.out.print(aa);
        }

2.2.4、自定义输出

 public static String arraysc(int []ints){
        if(ints==null){
            return "你输入的数组是null，无法输出！";

        }else if (ints.length==0){
            return "[]";
        }
        StringBuffer buffer=new StringBuffer("[");
        for (int i=0;i<ints.length;i++){
            if(i==ints.length-1){
                buffer.append(ints[i]+"]");
            }else{
                buffer.append(ints[i]+",");
            }
        }
        return buffer.toString();
    }

2.2.5、数组的最值

最大值最小值

    int[] arr=new int[]{1,2,3,4,5,6};
        int max=arr[0];
        int min=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }//拿一个进行下一个判断 是否大于或者小于 然后在进行赋值
            if(min>arr[i]){
                min=arr[i];
            }

        }
        System.out.println(max+","+min);

2.2.6、数组元素反转

• 数组作为方法的参数，传递的其实是数组的地址值。

• 数组作为返回值，接收到的其实也是数组的地址值。

3、排序算法

数组的冒泡排序

 //俩两对比
        int[] scores={100,99,98,97,60,96};
        for(int j=1;j<scores.length;j++) {
            for (int i = 0; i < scores.length-j; i++) {
                if (scores[i] > scores[i + 1]) {//一个数大约下一个的时候就
                    //用了移动
                    int temp = scores[i];//temp变量 ： 暂存scores【i】
                    scores[i] = scores[i + 1];//scores[i]原来的位置已经被覆盖
                    scores[i + 1] = temp;
                }
            }
        }
        for(int i:scores){
            System.out.println(i+"\t");
        }

冒泡排序（必须会）
扩展：选择排序，二分法排序，快速排序。。

4、Arrays数组工具类

boolean equals(array1,array2)：比较两个数组是否相等。

void sort(array):对数组array的元素进行升序排列

String toString(array)：把数组array转换成一个字符串。

void fill(array,val)：把数组array所有元素都赋值为val。

int binarySearch(array,val):查询元素值val在数组array中的下标

copyof(array,length)：把数组array复制成一个长度为length的新数组。

三、对象数组

3.1、简述

我们的数组 只要规定数据类型，那么就只能存储该类型的数据。

3.2、对象数组排序

测试类

public static void main(String[] args) {
        StudentManager studentManager=new StudentManager();
        //添加
        studentManager.dy(new Student("一",45));
        studentManager.dy(new Student("一",46));
        studentManager.dy(new Student("一",47));

        studentManager.print();
        //获取下标
        int a=studentManager.search(new Student("一",47));
        System.out.println("===============================");

        studentManager.delete(2);
        studentManager.print();
        //根据下标删除
        System.out.println("===============================");

        studentManager.delete(new Student("一",45));
        studentManager.print();
        System.out.println("===============================");
        //根据对象删除
        /*studentManager.aletr(new Student("一",46),new Student("修改",50));
        studentManager.print();
        System.out.println("===============================");*/
        //修改
        int b=studentManager.search(new Student("一",46));
        studentManager.aletr(b,new Student("修改",50));
        studentManager.print();
        }

管理类 封装的增删改查方法

public class StudentManager{
    Student[] students=new Student[4];
    int length=0;
    public void dy(Student stu){
        if(students.length==length){//判断是否相同就需要添加
            students= Arrays.copyOf(students,length+2);

        }
        students[length]=stu;//吧这个数放到这个位置
        length++;
    }
    public void print() {
        for (int i = 0; i < length; i++) {
            Student stu = students[i];
            //System.out.println(stuendts[i]);
            System.out.println(stu);

            // System.out.println(stu.getName()+","+stu.getAge());
        }
        /*for(Student student:students){
            System.out.println(student);
        }*/
    }/*  查找下标*/
        public int search(Student search){
            for(int i=0;i<length;i++) {
                Student stu = students[i];
                //地址是否相同 stu==search
                //年龄姓名相同就是i i就是下标啦  这时候返回i就行了
               // if(stu.getName()==search.getName()&&stu.getAge()==search.getAge()){
                //String重写---对比值   Student 也重写也可以比对值
                if(stu.equals(search)){
                    {
                        return i;
                    }
                }
            }
            return -1;
        }
/*根据下标删除对象*/
        public  boolean delete(int index){
            if(index>=length){
                return  false;
            }else{
                for (int i=index;i<length-1;i++){
                    students[i]=students[i+1];
                }
                students[length-1]=null;
                length--;
                return true;
            }
        }
/*根据对象删除*/
        //删除 传入的学生 一  这个时候传入的是一个对象先调用search方法获取下标 在调用delte方法删除下标
    public boolean delete(Student deleteObj){//获取对象
            int index=this.search(deleteObj);//查下标
            if(index==-1){//判断是否有这个下标
                return false;
            }
            return  this.delete(index);//有就输出
    }
    /*根据下标修改*/
    public void aletr(int index,Student aletr1){
        students[index]=aletr1;
    }
    /* 根据对象修改*/
    public boolean aletr(Student aletr1,Student aletr2){
        int index=this.search(aletr1);
        if(index==-1){
            return false;
        }
        students[index]=aletr2;
       return true;
    }
}

四、二维数组

将99乘法表放入二维数组，并输出

 public static void main(String[] args) {
        /*注意需要的数据类型*/
        String[][] ints=new String[9][];//定义了第一重数组长度为9，里边的长度不定

        int [][] aa=new int[2][2];//d定义来数组，第一重长度为2，第二重也一起new 出来来啦但是2--两行  两列---四个格子
        /*
        二维数组 
         数据类型 [][] 数组名 =new 数据类型 [第一重长度] [第二重长度]
        * */
        int [][] bb={{1,2,3},{11,22,33},{111,222,333}};
        for(int i=0;i<bb.length;i++){
            for (int  j=0;j<bb[i].length;j++){
                System.out.print(bb[i][j]+"\t");
            }
            System.out.println();
        }
            //开辟空间
        for (int i=0;i<ints.length;i++){
            ints[i]=new String[i+1];
        }
        //将乘法表的形式放到数组里面
        for (int i=0;i<ints.length;i++){
            for (int j=0;j<ints[i].length;j++){
                ints[i][j]=(i+1)+"*"+(j+1)+"="+(i+1)*(j+1);//给数组赋值
            }

        }
        //输出数组乘法表
        for (int i=0;i<ints.length;i++) {
            for (int j = 0; j < ints[i].length; j++) {
                System.out.print(ints[i][j] + "\t");
            }
            System.out.println();
        }
    }