Java基础系列--04_数组

一维数组：
　　(1)数组：存储同一种数据类型的多个元素的容器。
　　(2)特点：每一个元素都有编号，从0开始，最大编号是数组的长度-1。
　　　　　　编号的专业叫法：索引
　　(3)定义格式
　　　　A:数据类型[] 数组名;(一般用这种写法)
　　　　B:数据类型 数组名[];
　　(4)数组的初始化
　　　　A:动态初始化
　　　　　　只给长度，系统给出默认值
　　　　　　举例：int[] arr = new int[3];
　　　　B:静态初始化
　　　　　　给出值，系统决定长度
　　　　　　举例：int[] arr = new int[]{1,2,3};
　　　　　　　　或：int[] arr = {1,2,3};
　　(5)Java的内存分配
　　　　A:栈 存储局部变量(基本类型)
　　　　B:堆 存储所有new出来的（引用类型）
　　　　C:方法区(类和接口的方法)
　　　　D:本地方法区(系统相关)
　　　　E:寄存器(CPU使用)

　　注意：
　　　　a:局部变量 在方法定义中或者方法声明上定义的变量。
　　　　b:栈内存和堆内存的区别
　　　　　　栈：数据使用完毕，就消失。
　　　　　　堆：每一个new出来的东西都有地址
　　　　c:每一个变量都有默认值，并且数据使用完毕后，在垃圾回收器空闲的时候回收。

byte,short,int,long	0
float,double	0.0
char	'\u0000'
boolean	false
引用类型	null

　

　　(6)数组的常见操作
　　　　A:遍历

 //方式一：
 public static void printArray(int[] arr) {
     for(int x = 0; x < arr.length;  x++) {
         System.out.println(arr[x]);
     }
 }

 //方式2：
 public static void printArray(int[] arr) {
     System.out.print("[");
     for(int x=0; x<arr.length; x++) {
         if(x == arr.length-1) {
             System.out.println(arr[x]+"]");
         }else {
             System.out.println(arr[x]+", ");
         }
     }
 }                     

　　　B:最值

 //最大值
 public static int getMax(int[] arr) {
     int max = arr[0];       //假设第一个元素就是最大值
     for(int x = 1; x < arr.length; x++) {
         if(arr[x] > max) {    //将假设的最大值与其他元素比较，若发现有更大的则直接赋值。
             max = arr[x];
         }
     }
     return max;    //返回查找的最大值
 }

 //最小值：
 //与查找最大值的思想是一样的，假设第一个就是最小值，然后逐个进行比较
 public static int getMin(int[] arr) {
     int min = arr[0];
     for(int x = 1; x < arr.length; x++) {
         if(arr[x] < min) {
             min = arr[x];
         }
     }
     return min;
 }                    

　　C:逆序

 //方式1：
 public static void reverse(int[] arr) {
     for(int x = 0; x < arr.length/2; x++) {
         int temp = arr[x];
         arr[x] = arr[arr.length-1-x];
         arr[arr.length-1-x] = temp;
         /*使用异或位运算符交换
         arr[x] = arr[x]^arr[arr.length-1-x];
         arr[arr.length-1-x] = arr[x]^arr[arr.length-1-x];
         arr[x] = arr[x]^arr[arr.length-1-x]
         */
     }
 }

 //方式2：
 public static void reverse(int[] arr) {
     for(int start=0,end=arr.length-1; start<=end; start++,end--)             {
     int temp = arr[start];
     arr[start] = arr[end];
     arr[end] = temp;
     }
 }    
23 //两种方式的思想其实都是一样的，方式一利用了两个元素的索引相加为数组的长度减一；而方式二则是利用了两个变量分别从数组的始末位置相互靠拢，直到两个变量相遇
24 //推荐使用方式一，因为缺少一个变量，代码也更加的简洁，专业。

D:查表

 //根据某个元素吵着在数组中所在的值，不存在返回-1
 public static String getString(String[] strArray,int index) {
     return strArray[index];
 }

E:基本查找

//方式1：
public static int getIndex(int[] arr,int value) {
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            return x;    //找到了就返回索引
        }
    }
    return -1;    //没找到就返回-1
}

//方式2：比较专业
public static int getIndex(int[] arr,int value) {
    int index = -1;
    for(int x = 0; x < arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;        //找到了，修改索引，并跳出循环
        }
    }
    return index;      //没找到，返回-1
}        

F:二分查找（数组必须是有序的，假设是从小到大排序）

 public static int getIndex(int[] arr,int value)
 {
     int maxIndex = arr.length-1;
     int minIndex = 0;
     int midIndex = (maxIndex+minIndex)/2;

     while(arr[midIndex]!=value)
     {
         //查找的元素在左边
         if(arr[midIndex]>value){
             maxIndex = midIndex - 1;
         }
         //查找的元素在左边
          else if (arr[midIndex]<value) {
             minIndex = midIndex + 1;
         }
         //找不到
         if(minIndex > maxIndex){
             return -1;
         }
         //每查找一次，就重新定位中间元素的索引
         midIndex = (maxIndex+minIndex)/2;
     }

     return midIndex;
 }        

二维数组：
　　(1)元素是一维数组的数组。
　　(2)格式：
　　　　A:数据类型[][] 数组名 = new 数据类型[m][n];
　　　　B:数据类型[][] 数组名 = new 数据类型[m][];
　　　　C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
　　　　D:数据类型[][] 数组名 = {{...},{...},{...}};
　　(3)双重for循环遍历
　　　　A:二维数组的遍历
　　　　B:二维数组的求和
　　　　C:杨辉三角形

　　结论：其实二维数组可以看成是一张表，每一行都相当于是一个一维数组。其实际的操作无非就是从二维转到一维，在使用一维的想想去解决问题

　　注意：
　　　　(1)Java中的参数传递问题
　　　　　　Java中只有值传递。
　　　　　　基本类型：形式参数的改变不影响实际参数
　　　　　　引用类型：形式参数的改变直接影响实际参数

 //参数为基本类型
 public static void main(String[] args){
     int a = 10;
     int b = 20;
     String aStr = "hello";
     String bStr = "world";
     change(a, b);
     changer(aStr, bStr);
     System.out.println("a="+a+"; b="+b);　　//a=10;b=20
     System.out.println("aStr="+aStr+"; bStr="+bStr);　　//aStr=world;bStr=hello
 }

 //两个整型交换变量
 public static void change(int a,int b){
   int tem = a;
   a = b;
   b = temp;
 }
 //方法的重载；两个字符串的交换
 public static void change(String aStr,String bStr){
   String tem = aStr;
   aStr = bStr;
   bStr = tempStr;
 }