目录

一、数组

1、数组的定义

2、创建数组和初始化

2.1数组声明

2.2数组创建 

2.3数组的初始化

3、数组的常见操作

3.1数组的遍历

3.2for-each循环(增加for循环)

3.3数组的拷贝

4、java.util.Arrays类解析

4.1使用Arrays输出数组中的元素

4.2使用Arrays类对数组元素进行排序

4.3使用Arrays类对数组元素进行二分查找

4.4使用Arrays类对数组元素进行填充(替换数据)

4.5使用Comparable接口进行对象排序

5、多维数组

5.1二维数组的声明

5.2二维数组的初始化

5.3遍历二维数组

5.4获取数组长度

5.5Object数组储存表格数据

5.6使用javabean和数组储存表格数据

二、常见算法(与c++思想一致)

1、冒泡排序

2、二分法查找

一、数组

1、数组的定义

2、创建数组和初始化

数组的创建和初始化时是数组使用的第一步，我们通过内存分析也让大家更加深入的了解数组。同时，通过内存分析更加明白数组的本质还是“对象”。

2.1数组声明

数组的声明方法（以一维数组为例）：

type[]   arr_name//方法一

type  arr_name[]//方式二

注意事项：

1、声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。

2、声明一个数组的时候并没用数组真正被创建

3、创建一个数组，必须指定长度。

2.2数组创建 

创建基本类型一维数组：

package studyweek3;

public class shuzu1 {
    public static void main(String[] args) {
        int s[]=null;//声明数组
        s=new int[10];//给数组分配空间
        for(int i=0;i<10;i++){
            s[i]=2*i+1;//赋值
            System.out.println(s[i]);
        }
    }
}

创建引用类型

class Man{
    private int age;
    private int id;

    public int getAge() {
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    public Man(){};
    public Man(int id, int age){
        this.age=age;
        this.id=id;
    }
     @Override
    public String toString(){//根据自己所需对toString类进行重写
        return "id:"+id+",age:"+age;
        
    }
}
public class shuzu1{
    public static void main(String[] args) {
          //动态初始化
//        Man mans[];
//        mans=new Man[2];//Man[] mans=new Man[5];两种定义一致
//        Man m1=new Man(1,11);//该引用类型数组的元素是成员
//        Man m2=new Man(2,22);
//
//        mans[0]=m1;//给引用类型数组元素赋值
//        mans[1]=m2;//给引用类型数组元素赋值

       //静态初始化
        Man m1=new Man(1,11);
        Man mans[]={
                m1,
                new Man(2,22)
        };

        for(int i=0;i< mans.length;i++){
            System.out.println(mans[i].getId());
            System.out.println(mans[i].getAge());
        }

         
    }
}

2.3数组的初始化

1、数组的静态初始化

int a[]={1,2,3};

Man mans[]={new Man()}

注意：静态初始化要在声明后直接赋值

2、数组的动态初始化

int a[]=new int[];

a[0]=1;a[1]=2;

3、数组的默认初始化

int a[]=new int[2];//默认初始值0,0

boolean b[]=new boolean[2];//默认值false,false

String s[]=new String[2];//默认值null，null

3、数组的常见操作

3.1数组的遍历

3.2for-each循环(增加for循环)

增强for循环专门用于读取数组或集合中所有的元素，即进行遍历。

以上两者都在2中实现，这里不加描述

3.3数组的拷贝

4、java.util.Arrays类解析

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了:排序、查找、填充、打印内容等操作

4.1使用Arrays输出数组中的元素

package studyweek3;

import java.util.Arrays;

public class shuzu2 {
    public static void main(String[] args) {
        //打印数组，加上［］
        int a[]={100,200,300};
        System.out.println(a);//打印数组引用的地址
        System.out.println(Arrays.toString(a));//结果［100，200，300］
    }
}

注意：此处的Arrays.toString()方法是Arrays类的静态方法，不是前面所讲的Object类的toString()方法。

4.2使用Arrays类对数组元素进行排序

  //数组排序
        int b[]={1,3,6,9,7,5,7};
        System.out.println(Arrays.toString(b));
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));

4.3使用Arrays类对数组元素进行二分查找

 //二分查找
        int c[]={1,2,32,23,12,59};
        System.out.println(Arrays.toString(c));
        Arrays.sort(c);//使用二分查找必须先对数组进行排序
        System.out.println(Arrays.toString(c));
        //查到返回下标，没查到返回-1
        System.out.println("该元素的下标"+Arrays.binarySearch(c,12));

4.4使用Arrays类对数组元素进行填充(替换数据)

     //填充(替换数据)
        int d[]={1,2,32,23,12,59};
        System.out.println(Arrays.toString(d));
        Arrays.fill(a,2,4,100)//将2到4的下标元素替换成100。
        System.out.println(Arrays.toString(d));

4.5使用Comparable接口进行对象排序

 

 

5、多维数组

多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少）。

5.1二维数组的声明

package studyweek3;
//二维数组
public class shuzu3 {
    public static void main(String[] args) {
        //java中多维数组的声明和初始化从低维到高维。
        int a[][]=new int[3][];//一个一维数组长度为3
        a[0]=new int[2];//该数组中没一个元素又是一个一维数组
        a[1]=new int[4];
        a[2]=new int[3];
    }
}

5.2二维数组的初始化

1、二维数组的静态初始化

//静态初始化
public class shuzu3{
    public static void main(String[] args) {
        int a[][]={{1,2,3},{3,4},{5,6,7}};
        System.out.println(a[2][2]);
    }
}

下图是二维数组定义和初始化的核心 

 2、动态初始化

     int b[][]=new int[3][];
        b[0]=new int[]{1,2};
        b[1]=new int[]{1,2,3};
        b[2]=new int[]{2,3,4,5};
        System.out.println(b[2][2]);
        System.out.println(Arrays.toString(b[0]));//直接打印b[0]会直接打印出地址，因此要使用Arrays.toString
        System.out.println(Arrays.toString(b[1]));
        System.out.println(Arrays.toString(b[2]));

5.3遍历二维数组

一个一维数组，里面的元素是另一个数组或者是一个个对象时，是不可以直接使用Arrays.toString(xxx)进行遍历的，因为读取元素时都是数组或者对象，因此返回值全是地址，可以重写toString方法来实现遍历。

二维数组可以通过嵌套循环进行遍历，也可以通过fo循环+Arrays.toString(xxx[i])来进行遍历。

 关于数组遍历的具体说明https://blog.csdn.net/lilong117194/article/details/83716244

5.4获取数组长度

//获取的二维数组第一维数组的长度。

System.out.println(a.length);

//获取第二维第一个数组长度。

System.out.println(a[0].length);//需要哪一个二维的数组就用a[几]。

5.5Object数组储存表格数据

public class shuzu3{
    public static void main(String[] args) {
        //每一个一维数组代表一行数据
        Object emp0[]={1001,"高一",18,"程序员","2019-9-9"};
        Object emp1[]={1002,"高二",19,"程序员","2019-10-9"};
        Object emp2[]={1003,"高三",20,"程序员","2019-11-9"};

        Object[][] emps=new Object[3][];
        emps[0]=emp0;
        emps[1]=emp1;
        emps[2]=emp2;

        //遍历(表格数据打印)
        for(int i=0;i 
 
5.6使用javabean和数组储存表格数据 
public class shuzu3{
    public static void main(String[] args) {
        Emp emp0 = new Emp(1001, "高一", 18, "程序员", "2022-2-1");
        Emp emp1 = new Emp(1002, "高二", 19, "程序员", "2022-2-1");
        Emp emp2 = new Emp(1003, "高三", 20, "程序员", "2022-2-1");

        //静态初始化
        // Emp[] emps={emp0,emp1,emp2};
        //动态初始化
        Emp emps[] = new Emp[3];
        emps[0] = emp0;
        emps[1] = emp1;
        emps[2] = emp2;

        //遍历
        for(int i=0;i< emps.length;i++){
            System.out.println(emps[i]);
        }
    }
}
class Emp{
    private int id;
    private String name;
    private int age;
    private String job;
    private String hiredate;

    public Emp(){};

    public Emp(int id, String name, int age, String job, String hiredate) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.hiredate = hiredate;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }

    @Override
    //return最好要使用getId而不是id
    public String toString(){
        return getId()+"t"+getName()+"t"+getAge()+"t"+getJob()+"t"+getHiredate();
    }

}

 
 
二、常见算法(与c++思想一致) 
可视化算法网站https://visualgo.net/en
 
1、冒泡排序 
package 算法;

import java.util.Arrays;

public class maopaopaixu {
    public static void main(String[] args) {
        int a[]={3,5,4,7,9,1,2,0,5};
        bubbleSort(a);
        System.out.println(Arrays.toString(a));
    }

public static void bubbleSort(int a[]){

        for(int i=0;ia[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }
}
 
 
2、二分法查找 
 
 
二分查找一定要有序序列，因此一定要先排序。
 
 
分法检索（binarysearch）又称折半检索，二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组（array）中，首先将给定值key与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功；否则，若key小，则在数组前半部分中继续进行二分法检索;若key大，则在数组后半部分中继续进行二分法检索。这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。二分法检索是一种效率较高的检索方法。
 
package 算法;

import java.util.Arrays;

public class erfenchazhao {
    public static void main(String[] args) {
        int a[]={1,3,6,8,7,2,0,5,9,4};
        int x=6;
        Arrays.sort(a);//二分查找之前一定要对数组元素排序
        System.out.println(Arrays.toString(a));
        System.out.println(x+"元素索引："+binarySearch(a,x));
    }
    public static int binarySearch(int a[],int x){
        int low=0;
        int high=a.length-1;
        while(low<=high){
            int middle=(low+high)/2;
            if(x==a[middle]){
                return middle;
            }
            else if(x>a[middle]){
                low=middle+1;
            }
            else if(x