JAVA数组

Posted 2021-01-16 s1mplesama

　　　　　　数组是一种重要的数据结构

 

声明:第一种为JAVA风格声明,第二种为C/C++风格,可行但不推荐使用

dataType[] arrayRefVar;   // 首选的方法
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

 

创建数组：使用new操作符

　　一、

arrayRefVar = new dataType[arraySize];

　　　　　　　　1.先new一个数组dataType

　　　　　　　　2.把数组的引用赋值给arrayRefVar

　　　二、

dataType[] arrayRefVar = {value0, value1, ..., valuek};

　　　　　　　　直接在创建数组的时候给每个位置赋值

 

处理数组：　

　　一、普通循环（略）

　　二、foreach循环（JDK1.5后引进，能在不使用下标情况下遍历数组）

      for (double element: myList) {　　　　　　　　　　//double为数组内元素类型，myList为数组名
          //do sth       　　　　　　　　　　　　　　　　 //这里放对于数组里元素的操作　　　　　　　　　　　　　　　
      }        

 

数组可以作为函数的参数，也可以作为返回值

 

多维数组：

 

type arrayName = new type[arraylenght1][arraylenght2];

 

 

　　type为数组内数据类型，可以为基本数据类型，也可以为复合数据类型；　　

　　arraylenght1与2为正整数，分别为行和列；

　　

也可以这样定义一个数组：

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];

　　　　再对里面各个元素进行赋值。

 

Arrays类：

　　　　java.util.Arrays 类能方便地操作数组，里面所有方法都是静态的。

具体功能如下：

　　1.赋值：fill方法

　　　　　　　　public static void fill(int[] a, int val)

　　　　　　将指定int值分配给指定int型数组指定范围中的每个元素,byte,short,等其它基本数据类型同样适用

 

        // 将数组的第2和第3个元素赋值为8
       　　 Arrays.fill(array, 2, 4, 8);

 

 

  　2.排序：sort方法，升序

public static void sort(Object[] a)

　　　　　　　　对指定对象数组升序排列,其它基本数据类型同样适用

        // 对数组的第2个到第6个进行排序进行排序
        Arrays.sort(array1, 2, 7);

        // 对整个数组进行排序
        Arrays.sort(array1);

 

　　3.比较数组：equals方法比较数组中元素是否相等

 

1 public static boolean equals(long[] a, long[] a2)

 

　　　　　　判断两个数组是否顺序，数量，值都相等。其它基本数据类型通用

 

 

　　4.查找元素：binarySearch对已排序好的数组二分查找

public static int binarySearch(Object[] a, Object key)

　　　　　　　　　　二分查找，必须事先排序好，如果查找到对应值，返回相应的索引，否则返回负数

　　

 字符串转换为数组：

 

1         String str = "helloworld";
2         char[] data = str.toCharArray();// 将字符串转为数组

 

 

数组若大小不足可以使用Array.copyof()扩容:

1 Array.copy(E[] e,newLength);        //newLength为扩容后的总长度,非添加的长度

 

冒泡排序：

　　从头开始每次比较两个数的大小，把较大的值放在后面，较小的值放在前面；

　　一次内循环遍历一遍，把最大的值放在最后；

　　下一次循环不会遍历到最后一个值，把第二大的放在倒数第二位，以此类推；

　　最后的数组按从小到大升序排列；

        for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数
            for(int j=0; j< arr.length-i-1;j++) {  //内层循环控制每一趟排序多少次
                　　// 把小的值交换到前面
                if (arr[j]>arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
　　　　 }

 

选择排序：

　　　　第一次遍历一次数组，将最小的和最前面的数交换位置；

　　　　第二次遍历除第一个元素以外的所有元素，将第二小的和第二位换位置，以此类推；

　　　　最后数组按从小到大排列；

 1     public static int[] toSmall(int[] arr)
 2     {
 3 //遍历数组里除最后一个的其他所有数，因为最后的对象没有与之可以相比较的数
 4         for(int i=0;i<arr.length-1;i++)
 5         {
 6 /*遍历数组里没有排序的所有数，并与上一个数进行比较
 7  *“k=i+1”因为自身一定等于自身，所以相比没有意义
 8  *而前面已经排好序的数，在比较也没有意义
 9  */
10             for(int k=i+1;k<arr.length;k++)
11             {
12                 if(arr[k]<arr[i])//交换条件（排序条件）
13                 {
14                     int number=arr[i];
15                     arr[i]=arr[k];
16                     arr[k]=number;
17                 }//交换
18             }
19         }
20         return arr;
21     }

 

 

 

 生成五个不重复随机字符的代码：

 1 // 生成随机字符数组chs
 2     public static char[] generate() {
 3         char[] chs = new char[5];
 4         char[] letters = { ‘A‘, ‘B‘, ‘C‘, ‘D‘, ‘E‘, ‘F‘, ‘G‘, ‘H‘, ‘I‘, ‘J‘,
 5                 ‘K‘, ‘L‘, ‘M‘, ‘N‘, ‘O‘, ‘P‘, ‘Q‘, ‘R‘, ‘S‘, ‘T‘, ‘U‘, ‘V‘,
 6                 ‘W‘, ‘X‘, ‘Y‘, ‘Z‘ };
 7         boolean[] flags = new boolean[letters.length];
 8         for (int i = 0; i < chs.length; i++) {
 9             int index;
10             do {
11                 index = (int) (Math.random() * letters.length);
12             } while (flags[index] == true);
13             chs[i] = letters[index];
14             flags[index] = true;
15         }
16     17      18       
19         return chs;
20     }

代码解析：

 1 public static void generate(char [] chs){
 2     //char [] letter ... 这里定义一个char 类型的数组，存放26个字符
 3     //定义一个长度为26的布尔数组。 数组当然可以是boolean类型。每个元素的默认值为false
 4     //boolean[] flags = new boolean[letters.length];
 5    
 6      
 7     //这个for循环5次
 8     //for(int i = 0;i<chs.length;i++){
 9         int index;
10         do{
11             //Math.random()随机生成0-1之间的小数，   *letters.length  
12             //也就是*26   表示随机生成1-26之间的数字
13             //然后赋值给index
14             //然后执行while里的方法
15             //flags[inedx] 因为上面默认值是false 
16             //如果flags[inedx] 是false 讲其置为true
17              
18              
19             //其实这段代码的含义就是生成不重复的5个字母，如果生成过程中发现是重复的，则继续生成。
20              //假设 indedx 随机出来的分别是 5 5 4 8 6
21              //for循环第一次 index = 5   flags[5]为false;  所以执行 flags[5] = true;            
22              //for循环第二次 index =5  此时，flags[5]是true 所以while(true);继续执行do里面的方法
23                 
24                                 
25              //
26              index = (int)(Math.random()*(letters.length));           
27         }while(flags[index]);
28         flags[index] = true;
29     }
30 }