Javase 重要知识点总结 day04

关键词：数组
数组，就是一个容器，可以放很多数据（变量呢，只能放一个数据）。
数组呢，里面是一组相同数据类型的数据。（应用：以后你采集到的信息，字符型放一个数组，整型放一个数组。。。。）
格式：数据类型 [ ] 变量名=new 数据类型[数组长度]；
#1. 数组初始化
1）动态初始化，就是先占几个坑，告诉计算机，我有几个数据，计算机会忘坑里面，填进去默认值。如下表所示：
例如：int [ ] arr=new int[5];

数据类型 default值
int 0
浮点数 0.0
boolean false
char 空字符null
引用数据类型 null
引用数据类型，记录了变量的地址值，根据地址找空间，通过索引找对应的值。
//new 是一个关键字，代表在堆内存中开辟了一个新的内存空间。会有一个地址值，赋给变量arr。
2）静态初始化：就是直接给数组里面填数据了。
计算机自己会计算，数组的长度的。
格式： 数据类型 [ ] 变量名=new 数据类型[ ]{ 数据1，数据2，。。。。}
简化格式：数据类型 [ ] 变量名={数据1，数据2，数据3.。。。。。。。 } 这个我比较喜欢，哈哈哈。
#2.数组存储原理：

int [ ] arr=new int [ 5 ];
new会在堆内存中，开辟出一个空间，用于存储数组数据。
产生的地址值(0x12a)会给arr, 那么后续访问数组，计算机会根据，地址值找到空间，根据索引找位置，然后就可以取出数组里面的数据了。
#3.数组遍历
//遍历就是取出数据的过程，可以将取出的数据参与其他的运算。 不能简单理解为是打印哦。
案例：
需求：键盘输入5个数据，将数据存到数组中，并对数组求和。
import java.util.Scanner;
public class sumarry {
public static void main (String[]args){
Scanner sc=new Scanner(System.in);

    int [] arr=new int[5];
    int sum = 0;
    for(int i=0;i<arr.length;i++){
        System.out.println("请输入第"+i+"个数字");
        arr[i]=sc.nextInt();
        sum +=arr[i];
    }
    for(int i=0;i<arr.length;i++){
        sum+=arr[i];            
    }
    System.out.println(sum);
}   

}
4.排序（基本的一些排序方法，要知道原理，不需要记，因为后面会有简单直接的Array中sort和equals 方法，直接用它们就行了，哈哈。）
1)冒泡排序：就是将数组中的相邻两个元素进行比较，将较小的元素交换到前面。
原理：


本质上：就是第一轮，将最大的数字排到最后
第二轮，相邻元素比较后，将第二大的数字往后面挪动，排到倒数第二的位置。
就这样。。。。一点点往后面挪动。直到完成。

public class maoao {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       int [] arr={45,23,7,89,5};
       int temp;
       for(int i=0;i<arr.length-1;i++){
    	   //几轮，总共要比较arr.length-1 轮  
    	   for (int j=0;j<arr.length-1-i;j++){
    	//每一轮要比较几次：arr.length-1-i次
    		   if (arr[j]>arr[j+1]){
    			  temp=arr[j];
    			  arr[j]=arr[j+1];
    			  arr[j+1]=temp;
    		  }	   
    	   }  	 
       }    //for 增强循环，是为了遍历数组的=每一个元素，方便输出，嘛 
       for (int a:arr){
		   System.out.println(a);
	   }
	}
}

2）选择排序
从某个位置开始，与某个位置之后的元素进行比较
原理：

本质上：就是先想确定最小值，把第一个位置（索引）的值和其他位置（索引）的值比较，谁小，谁就坐上这个号主的位置。
同理，确定第二最小的值，把第二位置（索引）的值和之后位置的值比较，谁就做这个位置。
一句话，把最小的值，第二小的值，。。。一点点往前面挪动，直到完成。
案例:

package day04;
public class selectrank {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
      int [] arr={11,34,56,87,99,230};
      int temp;
      for(int i=0;i<arr.length-1;i++){
          //选择第几个位置，开始比较 
          for (int j=i+1;j<arr.length-1-j;j++){
              //这个位置之后的元素开始，与选定的元素比较
              if (arr[i]>arr[j]){
                  temp=arr[j];
                  arr[j]=arr[i];
                  arr[i]=temp;            
              }       
          }       
      }
        for (int a:arr){
            System.out.println(a);
        }
    }
}

注意：
return语句，是执行了return语句，那么方法（例如main方法，还有其他方法例如构造方法，等等，）后面的其它语句都不会执行，直接结束掉了。
for（）{
语句体1；
for( ){
语句体2；
break;
}
}
注意：
break 只会结束掉最里面的for循环，如果是return，他会直接结束掉main方法，后面的语句都不执行了。
#5.Array数组中的一些方法
toString
数组转换成字符串，用途：主要是为了展示数组中的元素，方便看。
用法： Arrays.toString(arr)
public static void main(String[] args) {
int [] arr = {33,11,22};
// 1. 把数组转换成字符串
String s = Arrays.toString(arr);
System.out.println(s);// [33, 11, 22]

Sort
//啥用：升序 排序，用法： Arrays.sort(arr);
// 2. 升序排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));// [11, 22, 33]
binarySearch(二分法抽象成的类，源码里有很多宝藏)
// 啥用： 查找元素在数组中的位置，， 用法： Array.binarySearch( arr ,15) 会返回元素15 在数组中的索引
// 3. 二分查找 : 前提 升序排序 ,返回 索引， 不存在返回负数，-插入点 -1
System.out.println(Arrays.binarySearch(arr, 15));// -2 -1-1
equals
啥用： 判断两个数组是否相等 （长度，相同位置的元素是否相等） 用法：Arrays.equals(arr1,arr2); 返回值肯定是true or false 了。
// 4. 两个数组是否相等 （长度 和 对应位置的元素 相等）
int [] arr1 = {11,22,33};
int [] arr2 = {11,22,33};
System.out.println(Arrays.equals(arr1, arr2));
fill
啥用：用给出的数据，替换掉数组中所有的数据。 此时，所有的数据都是一样的了。
用法： Arrays.fill(arr3,999); // 用数据999 替换掉数组arr3中所有的元素。
// 5.填充 (用第二个数据 替换掉 数组 的所有元素值）
int [] arr3 = {1,2,3};
Arrays.fill(arr3, 999);
System.out.println(Arrays.toString(arr3));// [999, 999, 999]
copyOf
啥用：复制数组中的元素
咋用： int [ ] arr5 = Arrays.copyOf(arr4, 4);// 根据 arr4 的元素 ，创键一个新的数组对象
4是 arr4.length，就是数组的长度。
方法使用：
// 6. 复制数组
int [] arr4 = {11,22,33,44};
int [] arr5 = Arrays.copyOf(arr4, 4);// 根据 arr4 的元素 创键一个新的数组对象
System.out.println(arr4);
System.out.println(arr5);
System.out.println(Arrays.toString(arr5));// [11, 22, 33, 44]
}
（
复制数组中的数组元素有很多方法，我比较喜欢简单直接的
在system类中已经封装号这个方法了，arraycopy，直接调用就可以了。记太多也没用，只需要会一种就可以了。）
#6. 二维数组、多维数组

所有的多维数组 ，本质上组成都是 一维数组。

conclusion：
除了一维数组中存储的是数组元素，二维数组、三维以及多维中存储的都是地址值
动态初始化 定义格式：
int [ ] [ ] arr = new int[3][2];
int [ ] [ ] [ ] arr =new int [3 ] [ 2] [ 3 ]; 几维数组，左边就几个方括号，

public static void main(String[] args) {
        Scanner superman = new Scanner(System.in);
        // 动态
        int [][] arr = new int[3][2];
        // 赋值
        //                       3 二维数组的元素的个数
        for(int i = 0; i < arr.length; i ++) {
            for(int j = 0; j < arr[i].length ; j ++) {
                arr[i][j] = superman.nextInt();
            }
        }
//      arr[0][0] = superman.nextInt();
/*      arr[0][0] = 12;
        arr[0][1] = 2;

特别注意 多维数组中
for的增强循环，遍历方式：

    // 增强for
        for(int [ ] ar:arr) {   // 注意是 int [ ] ar：arr
            for(int a: ar) {
                System.out.print(a + "\t");
            }
            System.out.println();
        }
    }

静态初始化：

// 静态初始化
        int [][] arr1 = {{12,2},{5,8,6},{14,12,44,3}};
        int [][] arr2 = new int[][] {{12,2},{5,8,6},{14,12,44,3}};
    }