黑马程序员_Java基础_数组

一、数组

同一种类型数据的集合,也就是一个容器。

声明：

1.元素类型[]数组名 = new元素类型[元素个数]

例：int[] arr = new int[5];

2.元素类型数组名[]  = new元素类型[元素个数]

例：int arr[] = new int[5];

3.元素类型[]数组名 = new元素类型[]{元素1，元素2，元素3，......}；

例：int[] arr =new int[]{1,2,3,4};

         int[] arr={1,2,3,4}

注：

JAVA中推荐用：类型[]数组名;

一个数组是一个对象

声明一个数组没有创建一个对象

声明时不用指定长度

 

创建基本数据类型数组：int[] i = new int[2];

创建引用数据类型数组：Student[] s = new Student[100];

数组创建后其中的元素有初始值

                            类型                    黙认值

                            byte                           0

                            short                          0

                            int                              0

                            long                           0l

                            float                          0.0f

                            double                       0.0d

                            char                          \u0000

                            boolean                     false

                            reference types           null

                   注：

                            创建时一定要指定长度

                            int[] i2=new int[];      //error

 

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

 

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

1.       数组和对象，通过new建立的实例都是存放在堆内存中。

2.       每一个实体都有默认初始化值。

3.       实体中的变量都有默认初始化值。

4.       实体不在被使用，会在不确定的时间内被垃圾回收器回收。

栈内存：自动释放。堆内存：垃圾回收机制。

Java的垃圾回收：

         由一个后台线程gc进行垃圾回收

         虚拟机判定内存不够的时候会中断代码的运行，这时候gc才进行垃圾回收

         缺点：不能够精确的去回收内存

         java.lang.System.gc();     建议回收内存，但系统不一定回应，他会先去看内存是否够用，够用则不予理睬，不够用才会去进行垃圾回收

         内存中什么算是垃圾：不在被引用的对象(局部变量，没有指针指向的)

 

二、数组的遍历

示例：

遍历数组

[java]  view plain copy

1. /* 
2. 遍历数组 
3. */  
4. class Test  
5. {  
6.     public static void main(String[] args)  
7.     {  
8.         int[] arr={1,2,3,4,5,6,7};  
9.         printArray(arr);//调用自定义函数  
10.     }  
11.     public static void printArray(int[] arr)//自定义遍历一维数组函数  
12.     {  
13.         for(int x=0;x<arr.length;x++)  
14.         {  
15.             if(x!=arr.length-1)  
16.                 System.out.print(arr[x]+",");  
17.             else  
18.                 System.out.print(arr[x]);  
19.         }  
20.     }  
21. }  

 

三、获取数组中最大值和最小值

[java]  view plain copy

1. /* 
2. 获取一维数组中的最大值和最小值 
3. */  
4. class ArrayTest   
5. {  
6.       
7.   
8.     public static int getMax(int[] arr)//获取最大值函数  
9.     {  
10.         int max=0;  
11.         for(int x=1;x<arr.length;x++)  
12.         {  
13.             if(arr[x]>arr[max])  
14.                 max=x;//存储最大值数组元素的脚标  
15.         }  
16.         return arr[max];  
17.     }  
18.     public static int getMin(int[] arr)//获取最小值函数  
19.     {  
20.         int min=0;  
21.         for(int x=1;x<arr.length;x++)  
22.         {  
23.             if(arr[x]<arr[min])  
24.                 min=x; //存储最值数组元素的脚标  
25.         }  
26.         return arr[min];  
27.     }  
28.       
29.     public static void main(String[] args)   
30.     {  
31.         int[] arr={1,3,2,5,5};  
32.         System.out.println("max="+getMax(arr)+"\n"+"min="+getMin(arr));  
33.     }  
34. }  

 

四、数组元素排序（选择排序）

[java]  view plain copy

1. /* 
2. 需求：选择排序 
3. 思路： 
4. 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的 
5. 数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。 
6. */  
7. class ArrayTest2   
8. {  
9.     public static void selectSort(int[] arr) //选择排序  
10.     {  
11.         for(int x=0;x<arr.length-1;x++)  
12.         {  
13.             for(int y=x+1;y<arr.length;y++)  
14.             {     
15.                 if(arr[x]>arr[y])//默认从小到大排序，需要从大到小排序，将“>”改为“<”  
16.                 {  
17.                     int temp=arr[x];  
18.                     arr[x]=arr[y];  
19.                     arr[y]=temp;  
20.                       
21.                 }  
22.   
23.             }  
24.          }  
25.     }  
26.   
27.     public static void printArray(int[] arr)//自定义遍历一维数组函数  
28.     {  
29.         for(int x=0;x<arr.length;x++)  
30.         {  
31.             if(x!=arr.length-1)  
32.                 System.out.print(arr[x]+",");  
33.             else  
34.                 System.out.print(arr[x]);  
35.         }  
36.     }  
37.   
38.   
39.     public static void main(String[] args)   
40.     {  
41.         int[] arr={1,3,4,6,2,7,5};  
42.         System.out.print("排序前：");//排序前  
43.         printArray(arr);//调用打印函数  
44.   
45.         System.out.print("\n排序后：");//排序后  
46.         selectSort(arr);//调用排序函数  
47.         printArray(arr);//排序后  
48.     }  
49. }  

五、数组元素排序（冒泡排序）

[java]  view plain copy

1. /* 
2. 需求：冒泡排序 
3. 思路： 
4. 冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个 
5. 数比后一个数大（则升序，小则降序）则交换两数 
6. */  
7. class ArrayTest2   
8. {  
9.       
10.     public static void bubbleSort(int[] arr)//冒泡排序  
11.     {  
12.         for(int x=0;x<arr.length-1;x++)//控制冒泡次数  
13.         {  
14.             for(int y=0;y<arr.length-1-x;y++)//控制比较次数  
15.             {  
16.                 if(arr[y]>arr[y+1])  
17.                 {  
18.                     int temp=arr[y];  
19.                     arr[y]=arr[y+1];  
20.                     arr[y+1]=temp;  
21.   
22.                 }  
23.             }  
24.         }  
25.     }  
26.   
27.     public static void printArray(int[] arr)//自定义遍历一维数组函数  
28.     {  
29.         for(int x=0;x<arr.length;x++)  
30.         {  
31.             if(x!=arr.length-1)  
32.                 System.out.print(arr[x]+",");  
33.             else  
34.                 System.out.print(arr[x]);  
35.         }  
36.     }  
37.   
38.   
39.     public static void main(String[] args)   
40.     {  
41.         int[] arr={1,3,4,6,2,7,5};  
42.         System.out.print("排序前：");//排序前  
43.         printArray(arr);//调用打印函数  
44.   
45.         System.out.print("\n排序后：");//排序后  
46.           
47.         bubbleSort(arr);//调用冒泡排序函数  
48.         printArray(arr);//排序后  
49.     }  
50. }  

六、数组元素排序（位置置换功能抽取）

发现无论什么排序。都需要对满足条件的元素进行位置置换，所以可以把这部分代码提取出来，单独封装成一个函数。

[java]  view plain copy

1. /* 
2. 需求：冒泡排序 
3. 思路： 
4. 冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个 
5. 数比后一个数大（则升序，小则降序）则交换两数 
6. */  
7. class ArrayTest2   
8. {  
9.     public static void bubbleSort(int[] arr)//冒泡排序  
10.     {  
11.         for(int x=0;x<arr.length-1;x++)//控制冒泡次数  
12.         {  
13.             for(int y=0;y<arr.length-1-x;y++)//控制比较次数  
14.             {  
15.                 if(arr[y]>arr[y+1])  
16.                 {  
17.                     swap(arr,y,y+1);  
18.                 }  
19.             }  
20.         }  
21.     }  
22.   
23.     public static void swap(int[] arr,int a,int b)//交换  
24.     {  
25.         int temp=arr[a];  
26.         arr[a]=arr[b];  
27.         arr[b]=temp;  
28.   
29.     }  
30.   
31.     public static void printArray(int[] arr)//自定义遍历一维数组函数  
32.     {  
33.         for(int x=0;x<arr.length;x++)  
34.         {  
35.             if(x!=arr.length-1)  
36.                 System.out.print(arr[x]+",");  
37.             else  
38.                 System.out.print(arr[x]);  
39.         }  
40.     }  
41.   
42.   
43.     public static void main(String[] args)   
44.     {  
45.         int[] arr={1,3,4,6,2,7,5};  
46.         System.out.print("排序前：");//排序前  
47.         printArray(arr);//调用打印函数  
48.   
49.         System.out.print("\n排序后：");//排序后  
50.         bubbleSort(arr);//调用冒泡排序函数  
51.         printArray(arr);//排序后  
52.     }  
53. }  

 

技巧：引入import java.util.*;通过Arrays.sort();也可以进行数组排序。

 

七、折半查找

[java]  view plain copy

1. /* 
2. 数组元素的查找操作 
3.  
4. */  
5. class ArrayTest3   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         int[] arr={2,3,4,6,8,64,78};  
10.         //int index=getIndex(arr,2);//遍历查找  
11.   
12.         //int index=halfSearch(arr,8);//折半查找方法1  
13.   
14.         int index=halfSearch_2(arr,8);//折半查找方法2  
15.           
16.           
17.         System.out.println("index="+index);  
18.     }  
19.   
20.     //折半查找，前提是数组元素是有序的。  
21.     public static int halfSearch(int[] arr,int key)//方法1  
22.     {  
23.         int min,max,mid;  
24.         min=0;  
25.         max=arr.length-1;  
26.         mid=(max+min)/2;  
27.   
28.         while(arr[mid]!=key)  
29.         {  
30.             if(key>arr[mid])  
31.             {     
32.                 min=mid+1;  
33.             }  
34.             else if(key<arr[mid])  
35.                 {  
36.                     max=mid-1;  
37.                 }  
38.   
39.             if(min>max)  
40.                 return -1;  
41.   
42.             mid=(max+min)/2;  
43.         }  
44.         return mid;  
45.     }  
46.   
47.       
48.     public static int halfSearch_2(int[] arr,int key)//方法2  
49.     {  
50.         int min=0,max=arr.length-1,mid;  
51.         while(min<=max)  
52.         {  
53.             mid=(max+min)/2;  
54.   
55.             if(key>arr[mid])  
56.             {  
57.                 min=mid+1;  
58.             }  
59.             else if(key<arr[mid])  
60.             {  
61.                 max=mid-1;  
62.             }  
63.             else  
64.                 return mid;  
65.         }  
66.         return -1;  
67.     }  
68.       
69.     //定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。  
70.     public static int getIndex(int[] arr,int key)  
71.     {  
72.         for(int x=0;x<arr.length;x++)  
73.         {  
74.             if(arr[x]==key)  
75.                 return x;  
76.         }  
77.         return -1;  
78.     }  
79. }  

[java]  view plain copy

1. //练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的。  
2.     public static int getIndex_2(int[] arr,int key)  
3.     {  
4.         int min=0,max=arr.length-1,mid;  
5.         while(min<=max)  
6.         {  
7.             mid=(max+min)/2;  
8.   
9.             if(key>arr[mid])  
10.             {  
11.                 min=mid+1;  
12.             }  
13.             else if(key<arr[mid])  
14.             {  
15.                 max=mid-1;  
16.             }  
17.             else  
18.                 return mid;  
19.         }  
20.         return min;//返回要插入的具体位置  
21.   
22.     }  

八、十进制->二进制和十进制->十六进制

[java]  view plain copy

1. /* 
2. 十进制->二进制和十进制->十六进制 
3. */  
4. class ArrayTest4   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         toBin(60);//十进制->二进制  
9.         toHex(60);//十进制->十六进制  
10.     }  
11.   
12.     public static void toBin(int num)//十进制->二进制函数  
13.     {  
14.         StringBuffer sb=new StringBuffer();  
15.         while(num>0)  
16.         {  
17.             sb.append(num%2);  
18.             num=num/2;  
19.         }  
20.         System.out.println(sb.reverse());  
21.     }  
22.   
23.     public static void toHex(int num)//十进制->十六进制函数  
24.     {  
25.         StringBuffer sb=new StringBuffer();  
26.   
27.         for(int x=0;x<8;x++)  
28.         {  
29.             int temp=num&15;  
30.             if(temp>9)  
31.             {  
32.                 sb.append((char)(temp-10+'A'));  
33.             }  
34.             else  
35.             {  
36.                 sb.append(temp);  
37.             }  
38.             num=num>>>4;  
39.         }  
40.         System.out.println(sb.reverse());  
41.     }  
42.   
43. }  

 

九、查表法进行十进制->十六进制和十进制->二进制

[java]  view plain copy

1. /* 
2. 查表法进行十进制->十六进制和十进制->二进制 
3. */  
4. class ArrayTest5   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         toHex(60);  
9.         toBin(60);  
10.     }  
11.     /* 
12.         0 1 2 3 4 5 6 7 8 9 A  B  C  D  E  F  (十六进制中的元素) 
13.         0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15  
14.  
15.         查表法：将所有的元素临时存储起来，建立对应关系。 
16.         每一次&15后的值作为索引去查建立好的表，就可以找到对应的元素。 
17.  
18.         可以通过数组的形式去定义。 
19.     */  
20.     public static void toHex(int num)//查表法16进制  
21.     {  
22.         char[] chs={'0','1','2','3','4',  
23.                     '5','6','7','8','9',  
24.                     'A','B','C','D','E','F'  
25.                    };//定义二进制表  
26.         char[] arr=new char[8];//定义一个临时存储容器，元素默认值'\u0000'。  
27.         int pos=arr.length;  
28.   
29.         while(num!=0)  
30.         {  
31.             int temp=num&15;  
32.             arr[--pos]=chs[temp];  
33.             num=num>>>4;  
34.         }  
35.         for(int x=pos;x<arr.length;x++)  
36.         {  
37.             System.out.print(arr[x]);  
38.         }  
39.         System.out.println();//换行  
40.     }  
41.   
42.     public static void toBin(int num)//查表法2进制  
43.     {  
44.         char[] chs={'0','1'};//定义二进制表  
45.         char[] arr=new char[32];//定义一个临时存储容器  
46.         int pos=arr.length;  
47.   
48.         while(num!=0)  
49.         {  
50.             int temp=num&1;  
51.             arr[--pos]=chs[temp];  
52.             num=num>>>1;  
53.         }  
54.   
55.         for(int x=pos;x<arr.length;x++)  
56.         {  
57.             System.out.print(arr[x]);  
58.         }  
59.         System.out.println();//换行  
60.     }  
61. }  

 

十、进制转换优化

[java]  view plain copy

1. /* 
2. 进制转换优化 
3. */  
4. class ArrayTest6   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         toBin(-3);  
9.         toOctal(30);  
10.         toHex(-20);  
11.     }  
12.       
13.     public static void toBin(int num)//十进制->二进制  
14.     {  
15.         trans(num,1,1);  
16.     }  
17.       
18.     public static void toOctal(int num)//十进制->八进制  
19.     {  
20.         trans(num,7,3);  
21.     }  
22.   
23.     public static void toHex(int num)//十进制->十六进制  
24.     {  
25.         trans(num,15,4);  
26.     }  
27.   
28.     public static void trans(int num,int base,int offset)  
29.     {  
30.         if(num==0)  
31.         {  
32.             System.out.println(0);  
33.             return;  
34.         }  
35.   
36.         char[] chs={'0','1','2','3','4',  
37.                     '5','6','7','8','9',  
38.                     'A','B','C','D','E','F'  
39.                    };  
40.         char[] arr=new char[32];//默认值'\u0000'  
41.         int pos=arr.length;  
42.   
43.         while(num!=0)  
44.         {  
45.             int temp=num&base;  
46.             arr[--pos]=chs[temp];  
47.             num=num>>>offset;  
48.         }  
49.         for(int x=pos;x<arr.length;x++)  
50.         {  
51.             System.out.print(arr[x]);  
52.         }  
53.         System.out.println();//换行  
54.     }  
55. }  

十一、         二维数组

 (其实是一个一维数组，它的每一个元素又是一个一维数组)

                   int[][] i1 = new int[2][3];

                   int[][] i4 = {{1,1,1},{2,2,2},{3,3,3}};

                   int[][] i3 = new int[][3];               //不允许高维没分配空间而先给低维分配空间

                   int[][] i2 = new int[2][];

                   i2[0] = new int[2];

                   i2[1] = new int[3];    

 

 

注意：

int[] x,int x[];//一维

int[][]y;int y[][]; int[] y[];//二维

 

int[] x,y[];//x一维，y二维

也就是：

int[] x;

int[] y[];

 

1.x[0]=y;//error

2.y[0]=x;//yes

3.y[0][0]=x;//error

4.x[0][0]=y;//error

5.y[0][0]=x[0];//yes

6.x=y;//error

 

练习：

[java]  view plain copy

1. /* 
2. 二维数组遍历 
3.  
4. */  
5. class ArrayTest7  
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         int a[][]=new int[][]{{1},{1,2},{1,2,3},{1,2,3,4}};//定义二维数组  
10.         for(int i=0;i<a.length;i++)  
11.         {   for(int j=0;j<a[i].length;j++)  
12.             {  
13.                 System.out.print(a[i][j]);  
14.             }  
15.             System.out.println();//换行  
16.         }  
17.     }  
18. }