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;  
}