1.JDK、JRE、JVM

JDK=JRE+开发工具集（如：javac编译工具等）

JRE=JVM+javaSE标准类库

image

2.数据的存储结构

（一对一）线性表：顺序表（如：数组）、链表、栈、队列

（一对多）树形结构：二叉树

（多对多）图形结构：

基本算法：排序和搜索

3.数组

数组特点：1.有序；2.数组本身是引用数据类型变量，但数组的元素既可以是引用数据类型，也可以是基本数据类型；3.数组会开辟一整块连续空间（链表就不连续）；4.数组长度一旦确定，就不能修改

一维数组定义：

//动态初始化：数组初始化和赋值分开进行

int[] arr = new int[4];

//静态初始化：数组初始化和赋值操作同时进行

int[] arr01 = new int[]{1,2};

数组的默认初始化值

整型：0 浮点型：0.0 char型：0或’\u0000‘，不是‘0’ boolean:false 引用数据类型：null

内存结构：

image

一维数组内存结构

image

二维数组：

    //动态初始化
int[][] arr02 = new int[3][2];
int[][] arr03 = new int[3][];

int[] arr04[] = new int[2][4];
//静态初始化
int[][] arr05 = new int[][]{{1,2},{2,4},{5,6}};
//类型推断
int[][] arr06 = {{1,2},{2,4},{5,6}};

/*
 * 二维数组默认初始化值：
 * 外层元素：地址值
 * 内层元素：与定义数组类型的一维数组默认初始化值一样
 * */

int[][] arr07 = new int[3][4];
System.out.println(arr07);//[[I@15db9742
System.out.println(arr07[0]);//[I@6d06d69c
System.out.println(arr07[0][0]);//0

int[][] arr08 = new int[3][];
System.out.println(arr08);//[[I@7852e922
System.out.println(arr08[0]);//null
System.out.println(arr08[0][0]);//报错

二维数组内存解析

图片.png

数组简单算法：
1.算法考察： 求数值型数组中元素的最大值、最小值、平均数、总和等

    /*
     *定义一个int型一维数组，包含10个元素，分别赋一些随机整数；
     *求出所有元素的最大值、最小值、平均数、总和。
     *要求：所有随机数都是两位
     * * */
    int[] arr = new int[10];
    for(int i = 0;i < arr.length;i++){
        arr[i] = (int) (Math.random()*(90)+10); //Math.random()*100有可能返回一位整数
        System.out.print(arr[i]+"\t");
    }
    Sysm.out.println();
    /*
     * 最大值
     * */
    int maxValue = arr[0];//若全都是负数，则赋0不对，故定义第一个为maxValue
    for(int i = 0;i < arr.length;i++){
        if(maxValue < arr[i]){
            maxValue = arr[i];
        }
    }
    System.out.println(maxValue);
    /*
     * 最小值
     * */
    int minValue = arr[0];//若全都是负数，则赋0不对，故定义第一个为maxValue
    for(int i = 0;i < arr.length;i++){
        if(minValue > arr[i]){
            minValue = arr[i];
        }
    }
    System.out.println(minValue);
    /*
     * 总数
     * */
    int sum = 0;//若全都是负数，则赋0不对，故定义第一个为maxValue
    for(int i = 0;i < arr.length;i++){
        sum += arr[i];
    }
    System.out.println(sum);
    
    /*
     * 平均数
     * */
    double avg = 0;//若全都是负数，则赋0不对，故定义第一个为maxValue
    avg = (sum / arr.length)*0.1;
    System.out.println(avg);

2.使用二维数组打印一个10行杨辉三角

/*
     * 杨辉三角：
     * 1.第一行有1个元素，第n行有n个元素
     * 2.每行的开头和末尾都为1
     * 3.第3行开始，对于每行的非第1和最后一个元素，a[i][j] = a[i-1][j]+a[i-1][j-1]
     * */
    int[][] arr = new int[10][];
    //给数组元素赋值
    for(int i = 0;i < arr.length;i++){
        //第一行有1个元素，第n行有n个元素
        arr[i] = new int[i+1];
        //2.1给首末元素都赋值为1
        arr[i][0] = arr[i][i] = 1;
        //2.2给非首末元素赋值
        if(i > 1){
            for(int j = 1; j < arr[i].length-1;j++){
                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]+"\t");
        }
        System.out.println();
    }

使用简单数组

     * 使用简单数组
     * 1.创建一个名为ArrayTest的类，在main方法中声明array1和array2两个变量，他们是int[]类型的数组
     * 2.使用{  }，把array1初始化为8个素数，2,3,5,7,11,13,17,19
     * 3.显示array1的内容
     * 4.赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2）打印array1
     * 
     * array1和array2的关系，仅仅是公用同一个地址
     * */
    int[] array1,array2;
    array1 = new int[]{2,3,5,7,11,13,17,19};
    array2 = new int[8];

    for(int i = 0;i < array1.length;i++){
        System.out.print(array1[i]+"\t");
    }
    System.out.println();
    //将array1赋值给array2，不能称作数组的复制
    array2 = array1;//即仅仅给的是array1的地址
    //偶元素索引
    for (int i = 0; i < array2.length; i++) {
        if(i % 2 == 0){
            array2[i] = i;
        }
        System.out.print(array2[i]+"\t");
    }
    //打印array1
    for(int i = 0;i < array1.length;i++){
        System.out.print(array1[i]+"\t");
    }

3.数组的复制

//数组的复制。即区别于数组的赋值
    for(int i = 0;i < array1.length;i++){
        array2[i] = array1[1];
        System.out.print(array1[i]+"\t");
    }

4.数组的反转

//数组的反转
    //方法一
    int[] arr = new int[]{2,3,5,7,17,19};
    for(int i = 0; i < arr.length / 2 ;i++){
         int temp = arr[i];
         arr[i] = arr[arr.length - i - 1];
         arr[arr.length - i - 1] = temp;
    }
    for(int i = 0;i < arr.length;i++){  
        System.out.print(arr[i]+"\t");
    }
    System.out.println();
    //方法二
        int[] arr1 = new int[]{2,3,5,7,11,17,19};
        for(int i = 0,j = arr.length-1; i < j ;i++,j--){
             int temp = arr[i];
             arr[i] = arr[j];
             arr[i] = temp;
        }
        for(int i = 0;i < arr.length;i++){  
            System.out.print(arr[i]+"\t");
        }

5.数组的线性查找

       /*
        * 数组的线性查找
        * */
       String[] arr = new String[]{"a","b","c"};
       String str = "d";
       boolean isFlag = true;
       for (int i = 0; i < arr.length; i++) {
           if(str.equals(arr[i])){
               System.out.println("找到元素位置为："+i);
               isFlag = false;//
               break;//找到就跳出循环
           }       
       }
       if(isFlag){
           System.out.println("没找到");

       }

6.二分法查找:查找的元素所在对象必须有序排列（速度快）

/*
         * 二分法查找
         * */
        int[] arr = new int[]{-90,-34,-25,2,5,8,10,25,67};
        int dest = 2;
        int head = 0;//定义头
        int end = arr.length - 1;//定义尾
        boolean isFlag = true;
        while(head <= end){//对最后一个位置也得进行比较
            int mid = (head + end) / 2;
            if(dest == arr[mid]){
                System.out.println("找到元素位置为："+mid);
                isFlag = false;
                break;
            }else if(dest > arr[mid]){
                head = mid + 1;
            }else{
                end = mid - 1;
            }
        }
        if(isFlag){
            System.out.println("没找到");
        }

7.冒泡排序：依次比较相邻的两个元素，将最大值依次交换到末尾，冒泡完的数组为顺序排序

/*
         * 冒泡排序：
         * */
        int[] arr = new int[]{23,-5,26,-59,-42,5,86,99};
        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]){//比较相邻两个元素的大小
                    int 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]+"\t");
        }

8.快速排序**