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:遍历

 1 //方式一：
 2 public static void printArray(int[] arr) {
 3     for(int x = 0; x < arr.length;  x++) {
 4         System.out.println(arr[x]);
 5     }
 6 }
 7 
 8 //方式2：
 9 public static void printArray(int[] arr) {
10     System.out.print("[");
11     for(int x=0; x<arr.length; x++) {
12         if(x == arr.length-1) {
13             System.out.println(arr[x]+"]");
14         }else {
15             System.out.println(arr[x]+", ");
16         }
17     }
18 }

　　　B:最值

 1 //最大值
 2 public static int getMax(int[] arr) {
 3     int max = arr[0];       //假设第一个元素就是最大值 
 4     for(int x = 1; x < arr.length; x++) {
 5         if(arr[x] > max) {    //将假设的最大值与其他元素比较，若发现有更大的则直接赋值。
 6             max = arr[x];
 7         }
 8     }
 9     return max;    //返回查找的最大值
10 }
11 
12 //最小值：
13 //与查找最大值的思想是一样的，假设第一个就是最小值，然后逐个进行比较
14 public static int getMin(int[] arr) {
15     int min = arr[0];
16     for(int x = 1; x < arr.length; x++) {
17         if(arr[x] < min) {
18             min = arr[x];
19         }
20     }
21     return min;
22 }

　　C:逆序

扫描二维码关注公众号，回复： 5616841 查看本文章

 1 //方式1：
 2 public static void reverse(int[] arr) {
 3     for(int x = 0; x < arr.length/2; x++) {
 4         int temp = arr[x];
 5         arr[x] = arr[arr.length-1-x];
 6         arr[arr.length-1-x] = temp;
 7         /*使用异或位运算符交换
 8         arr[x] = arr[x]^arr[arr.length-1-x];
 9         arr[arr.length-1-x] = arr[x]^arr[arr.length-1-x];
10         arr[x] = arr[x]^arr[arr.length-1-x]
11         */
12     }
13 }
14 
15 //方式2：
16 public static void reverse(int[] arr) {
17     for(int start=0,end=arr.length-1; start<=end; start++,end--)             {
18     int temp = arr[start];
19     arr[start] = arr[end];
20     arr[end] = temp;
21     }
22 }    
23 //两种方式的思想其实都是一样的，方式一利用了两个元素的索引相加为数组的长度减一；而方式二则是利用了两个变量分别从数组的始末位置相互靠拢，直到两个变量相遇
24 //推荐使用方式一，因为缺少一个变量，代码也更加的简洁，专业。

D:查表

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

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:二分查找（数组必须是有序的，假设是从小到大排序）

 1 public static int getIndex(int[] arr,int value)
 2 {
 3     int maxIndex = arr.length-1;
 4     int minIndex = 0;
 5     int midIndex = (maxIndex+minIndex)/2;
 6 
 7     while(arr[midIndex]!=value)
 8     {
 9         //查找的元素在左边
10         if(arr[midIndex]>value){
11             maxIndex = midIndex - 1;
12         }
13         //查找的元素在左边
14          else if (arr[midIndex]<value) {    
15             minIndex = midIndex + 1;
16         }
17         //找不到
18         if(minIndex > maxIndex){
19             return -1;
20         }
21         //每查找一次，就重新定位中间元素的索引
22         midIndex = (maxIndex+minIndex)/2;
23     }
24     
25     return midIndex;
26 }

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

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

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

 1 //参数为基本类型
 2 public static void main(String[] args){
 3     int a = 10;
 4     int b = 20;
 5     String aStr = "hello";
 6     String bStr = "world";
 7     change(a, b);
 8     changer(aStr, bStr);
 9     System.out.println("a="+a+"; b="+b);　　//a=10;b=20
10     System.out.println("aStr="+aStr+"; bStr="+bStr);　　//aStr=world;bStr=hello
11 }
12 
13 //两个整型交换变量
14 public static void change(int a,int b){
15   int tem = a;
16   a = b;
17   b = temp;  
18 }
19 //方法的重载；两个字符串的交换
20 public static void change(String aStr,String bStr){
21   String tem = aStr;
22   aStr = bStr;
23   bStr = tempStr;  
24 }

Java基础系列--04_数组

猜你喜欢