20151009学习整理

  1 //String[] qew = new String[5];
  2         
  3         char[] csz = new char[5];
  4         csz[0] = ‘f‘;//定义什么类型的就放置什么类型数值
  5         
  6         double[] dsz = {1,2,3,};//直接放置数值
  7         
  8         long lsz[] = new long[]{1,3,5,2};//直接开辟空间将值放置进去就可以了
  9 
 10         //取数组的值,数组索引值是从0开始计算
 11         long l = lsz[2];//l  的值是 122；
 12         
 13         
 14         
 15         //遍历
 16         
 17         int i =0;
 18         while(i < lsz.length)//下标值要小于索引值
 19         {
 20             System.out.println("lsz["+i+"]"+lsz[i]);
 21             i++;
 22         }
 23         
 24         
 25         
 26         //foreach 语句，从头到尾循环完毕后自动结束
 27         for(double d : dsz)//将dsz数组中的所有数据挨个拿出查看
 28         {
 29             System.out.println("d = "+d);
 30         }
 31         
 32         
 33         
 34         
 35         
 36         
 37     //二维数组    
 38         int[][] ewsz = new int[2][3];//比喻为两行三列数组,
 39         
 40         ewsz[0] = new int[]{1,2,3};//ewsz[0]  第一个数组赋予的值
 41         ewsz[1] = new int[]{4,5,6};//ewsz[1]  第二个数组赋予的值
 42         
 43         System.out.println("ewsz = "+ewsz[1][2]);//表示ewsz[1] 中的第三个数，因为索引为0，所以从0开始
 44         
 45         System.out.println("ewsz = "+ewsz.length);//输出为2，ewsz.length 数组长度的代码
 46                                                     //ewsz[].length  二维数组里面的长度
 47         
 48         //二维数组遍历
 49         //foreach
 50         
 51         for(int[] ie : ewsz)//取出每一行数据，相当于取出一个一位数组
 52         {
 53             for(int f : ie)//每一行数据输出一次
 54             {
 55                 System.out.print(f + " ");
 56             }
 57             System.out.println();
 58         }
 59         
 60         //for
 61         for(int m = 0;m < ewsz.length; m++)//ewsz.length  数组的长度，其实就是行数长度
 62         {
 63             for(int n = 0;n < ewsz[m].length; n++)//ewsz[m].length 数组里面的长度 相当于列数长度
 64             {
 65                 System.out.print(ewsz[m][n]+" ");
 66             }
 67             System.out.println();
 68         }
 69         
 70         
 71         
 72         
 73         long[][] lesz = new long[2][];
 74         
 75         lesz[0] = new long[]{1,5};
 76         lesz[1] = new long[]{6,2,7,9};
 77         
 78         for(int m = 0;m < ewsz.length; m++)//ewsz.length  数组的长度，其实就是行数长度
 79         {
 80             for(int n = 0;n < ewsz[m].length; n++)//ewsz[m].length 数组里面的长度 相当于列数长度
 81             {
 82                 System.out.print(ewsz[m][n]+" ");
 83             }
 84             System.out.println();
 85         }
 86         
 87         //操作数组
 88         
 89         Arrays.sort(lsz);//排序
 90         
 91         //复制数组    
 92         
 93         long[] lsz2 = lsz;
 94                 
 95         long[] lsz3 = Arrays.copyOf(lsz, 2);//将前两个数组数值复制给lsz3
 96                 
 97         long[] lsz4 = Arrays.copyOfRange(lsz, 1, 3);
 98                 
 99         //查询数组，返回索引值,如果没有找到会返回一个负数，可以判断是否包含某元素
100         
101         System.out.println("2的索引位置 = "+ Arrays.binarySearch(lsz, 2));
102         
103         //填充  
104         Arrays.fill(lsz2, 2);//将里面所有元素全部赋值为2
105         Arrays.fill(lsz3, 1, 3, 8);//从1到3 全部填充8进去

  1 //冒泡排序
  2         int[] sz = {23,12,56,97,19,30,7,21};
  3         
  4         for(int i : sz)
  5         {
  6             System.out.print(i + ",");
  7         }
  8         
  9         System.out.println();
 10         
 11         
 12         
 13         //这是第一轮排序
 14         for(int i = 0;i < sz.length - 1;i++)//数组长度为7，sz.length的值为7，而下方i+1会溢出，所以此处需要减一。
 15         {
 16             if(sz[i] > sz[i + 1 ])
 17             {
 18                 int t = sz[i + 1];
 19                 
 20                 sz[i + 1] = sz[i];
 21                 
 22                 sz[i] = t;
 23             }
 24         }
 25         for(int i : sz)
 26         {
 27             System.out.print(i + ",");
 28         }
 29         
 30         System.out.println();
 31         
 32         //冒泡排序全部排序
 33         //由小到大排列
 34         for(int j = 1;j < sz.length; j++)//for(int j = sz.length;j > 1; j--)控制检索的循环次数，最后一次比较无意义，因为最大的已经放置在最后，所以只进行6次检索
 35         {
 36             for(int i = 0;i < sz.length - j; i++)
 37             {
 38                 if(sz[i] > sz[i + 1 ])            //控制数值排序方式,由小到大·由大到小
 39                 {
 40                     int t = sz[i + 1];
 41                     
 42                     sz[i + 1] = sz[i];
 43                     
 44                     sz[i] = t;
 45                 }
 46             }
 47         
 48         }
 49         for(int i : sz)
 50         {
 51             System.out.print(i + ",");
 52         }
 53         
 54         System.out.println();
 55         
 56         //由大到小排列
 57         for(int j = 1;j < sz.length; j++)
 58         {
 59             for(int i = 0;i < sz.length - j; i++)
 60             {
 61                 if(sz[i] < sz[i + 1 ])
 62                 {
 63                     int t = sz[i + 1];
 64                     
 65                     sz[i + 1] = sz[i];
 66                     
 67                     sz[i] = t;
 68                 }
 69             }
 70         
 71         }
 72         for(int i : sz)
 73         {
 74             System.out.print(i + ",");
 75         }
 76         
 77         System.out.println();
 78         
 79         
 80         
 81         
 82         for(int a = sz.length;a > 0;a--)
 83         {
 84             for(int b = 0;b < sz.length - 1;b++)
 85             {
 86                 if(sz[b] > sz[b + 1])
 87                 {
 88                     int c = sz[b];
 89                     
 90                     sz[b] = sz[b + 1];
 91                     
 92                     sz[b + 1] = c;
 93                 }
 94             }
 95         }
 96         for(int i : sz)
 97         {
 98             System.out.print(i +",");
 99         }
100         System.out.println();