黑马程序员_数组

 1 public class Demo{
 2     public static void main(String[] args){
 3         //1. 声明数组. 
 4         int[] arr; 
 5         //2. 初始化数组(容器)  ,可以明确数组中存储的数据的个数. 
 6         arr=new int[3]; 
 7         
 8         // 可以访问堆内存这个空间. 
 9         System.out.println(arr);
10         // 访问数组编号为0位置的元素 
11         System.out.println(arr[0]); 
12         // 往数组的指定位置存储元素. 
13         arr[0]=100; 
14         System.out.println(arr[0]); 
15         
16         // 实际开发. 各种各样的数组(不同数据类型的,长度不同的数组) 数组的声明和初始化一行完成... 
17         int[] arr1=new int[5]; 
18         char[] arr2=new char[3];
19         boolean [] arr3=new boolean[2];
20         double[] arr4=new double[10]; 
21         String[] arr5=new String[100]; 
22         
23         // 使用数组存储数据. 
24         arr[0]=1;
25         arr[1]=100;
26         arr[2]=5; 
27         // 取出数组中每一个角标位置存储的元素.
28         System.out.println(arr[0]);
29         System.out.println(arr[1]);
30         System.out.println(arr[2]); 
31     }
32 }

 1 public class Demo1{
 2     public static void main(String[] args){
 3         int[] arr={10,8,7,2,5};
 4         printArr(arr);
 5         //bubbleSort(arr);
 6         selectSort(arr);
 7         printArr(arr);    
 8     }
 9     /**
10         选择排序:
11             第一次: 取出数组的0角标位置的元素,和0角标后的所有元素比较大小. 
12                    只要arr[0]>arr[0之后],就互换元素. 保证数组0角标位置存储的是一个最小值. 
13             第二次: 取出数组的1角标位置的元素,和1角标后的左右元素比较大小. 
14                 只要arr[1]>arr[1之后],就互换, 保证数组1角标位置出现较小值
15             第三次: 取出数组2角标位置元素... 
16                 数组2角标位置出现了较小值. 
17             ...
18             如果数组中有N 个元素,这个需要持续N-1次... 
19     */
20     public static void selectSort(int[] arr){
21         for(int j=0;j<arr.length-1;j++){
22             for(int i=j+1;i<arr.length;i++){
23                 if(arr[j]>arr[i]){
24                     int temp=arr[j];
25                     arr[j]=arr[i];
26                     arr[i]=temp; 
27                 }
28             }
29         }
30     }
31     
32     /**
33         冒泡排序:
34             前一个元素和后一个元素比价大小. 
35             只要arr[n]>arr[n+1] 就互换位置. 
36             数组的每一个位置的元素都和后一个位置元素进行比较大小(避免数组最后一个元素)可以找出一个最值放在数组的最后...  
37     */
38     public static void bubbleSort(int[] arr){
39         //外层循环循环一次,保证数组超出一个最值,放在了数组的后边.
40         //-1 5个元素,只需要4次,就可以找出最值了. 
41         for(int j=0;j<arr.length-1;j++){
42             //内层循环: -1 避免越界  前一个元素和后一个元素比较大小.5个元素,循环应该4次. 
43             //内层循环 -j  提高性能(效率),避免重复性的比较. 内层循环执行一次,数组就出现一个最值,该值避免参与重复的比较. 
44             for(int i=0;i<arr.length-1-j;i++){
45                 if(arr[i]>arr[i+1]){
46                     int temp=arr[i];
47                     arr[i]=arr[i+1];
48                     arr[i+1]=temp; 
49                 }
50             }
51         }
52     }
53     
54     public static void printArr(int[] arr){
55         System.out.print("["); // 开始[
56         for(int i=0;i<arr.length;i++){
57             if(i==arr.length-1){ // 如果最后一个元素,元素后不加逗号
58                 System.out.print(arr[i]);
59             }else{
60                 System.out.print(arr[i]+","); // 如果不是,元素后加逗号
61             }
62         }
63         System.out.println("]"); // 结束] 并换行. 
64     }
65 }
66 /**
67         二分查找:
68             当数组有序: 提升查找的性能. 使用二分查找. 
69     */
70     public static int binarySearch(int[] arr,int key){
71         int start=0; // 定位数组的开始
72         int end=arr.length-1; // 定位在数组的最右角标位置.
73         while(start<=end){ // 控制循环. 
74             int mid=(start+end)/2; 
75             if(key>arr[mid]){
76                 System.out.println("要找的key 在右边."); 
77                 start=mid+1; 
78             }else if(key<arr[mid]){
79                 System.out.println("要找的key 在左边"); 
80                 end=mid-1; 
81             }else{
82             System.out.println("找到了...");
83                 return mid;  //要找的key 和arr[mid] 重合的
84             } 
85         }
86         return -1; // 如果找不到返回-1. 
87     }