• 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();
    下午所学:冒泡排序及相关知识

     

  • 相关阅读:
    程序员获取编程灵感的10 种方式
    修改Windows远程桌面3389端口
    修改Windows远程桌面3389端口
    JS 开发常用工具函数
    JS 开发常用工具函数
    IT公司老板落水,各部门员工怎么救
    IT公司老板落水,各部门员工怎么救
    如何优雅地给妹子优化电脑(Windows)?
    如何优雅地给妹子优化电脑(Windows)?
    程序员,你恐慌的到底是什么?
  • 原文地址:https://www.cnblogs.com/name-hanlin/p/4865375.html
Copyright © 2020-2023  润新知