java之数组

数组概述

关于数组我们可以把它看作是一个类型的所有数据的一个集合，并用一个数组下标来区分或指定每一个数，例如一个足球队通常会有几十个人，但是我们来认识他们的时候首先会把他们看作是某某对的成员，然后再利用他们的号码来区分每一个队员，这时候，球队就是一个数组，而号码就是数组的下标，当我们指明是几号队员的时候就找到了这个队员。 同样在编程中，如果我们有一组相同数据类型的数
据，例如有10个数字，这时候如果我们要用变量来存放它们的话，就要分别使用10个变量，而且要记住这10个变量的名字，这会十分的麻烦，这时候我们就可以用一个数组变量来存放他们，例如在VB中我们就可以使用dim a(9) as integer（注意：数组的下标是从0开始的，所以10个数的话，下标就是9,a(0)=1）。 使用数组会让程序变的简单，而且避免了定义多个变量的麻烦。

数组的定义：

数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的四个基本特点：

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型,不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

数组声明创建

1、声明数组
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自
C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。
2、创建数组

Java语言使用new操作符来创建数组，语法如下：
//1.声明一个数组
        int[] mylist = null;
// 2.创建一个数组
        mylist = new int[4];
        //3.在数组中存值
        mylist[0] = 1;
        mylist[1] = 2;
        mylist[2] = 3;
        mylist[3] = 4;
//静态初始化；定义数组的同时就为数组元素分配空间并赋值
        int[] a={1,2,3};
 
//动态初始化：数组定义、为数组元素分配空间、赋值的操作、分开进行
        int[] b = new int[2];
        b[0] = 1;
        b[1] = 2;
下面是另一种方式对创建数组的描述：
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

double[] myList; // 首选的方法
或
double myList[]; // 效果相同，但不是首选方法
arrayRefVar = new dataType[arraySize];//大概是动态创建

上面的语法语句做了两件事：

一、使用 dataType[arraySize] 创建了一个数组。
二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

下面是个人总结：

1：打印数组要用：Arrays.toString() //导入操纵数组的包import java.util.Arrays
2：java中的变量创建需要给他指定类型，该变量赋值给另外一个变量，若不同类型需要强制转换，加上变量的属性

//将数组转化为列表
       int[] a12 = {3,5,1,9,7};
       List<int[]> list = Arrays.asList(a12);
       System.out.println(" Arrays.asList将数组转化为列表："+list);

3:方法直接调用，有return才赋值给变量，这样它可以打印出来
1：给数组赋值：通过 fill 方法。
2：对数组排序：通过 sort 方法,按升序。
3：比较数组：通过 equals 方法比较数组中元素值是否相等。
4：查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
2：Arrays.sort(mylist1);排序
4：Arrays.binarySearch(mylist1, 3.4))//查找数组元素3.4的索引
1：Arrays.fill(mylist1, 0,2, 100)//替换数组mylist1中0，2索引的元素为100
For-Each循环能在不使用下标的情况下遍历数组

 for(double element:mylist1){//element是必要的参数，mylist1是数组，double是数据类型
           System.out.println(element);
       }

完整代码

import java.util.Arrays;//导入操控数组的包
import java.util.List;

public class Array_test {
   public static void main(String[] args) {
        //1.声明一个数组
        int[] mylist = null;
        /*1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有
关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
2. 声明一个数组的时候并没有数组被真正的创建。
3. 构造一个数组，必须指定长度 */

        // 2.创建一个数组
        mylist = new int[4];
        //3.在数组中存值
        mylist[0] = 1;
        mylist[1] = 2;
        mylist[2] = 3;
        mylist[3] = 4;
        // 计算所有元素的总和
        double total = 0; //这里扩大变量的存储空间
        for(int i = 0 ;i<mylist.length;i++){
            total += mylist[i];
        }
        System.out.println("总和为："+total);
        
        
        //静态初始化；定义数组的同时就为数组元素分配空间并赋值
        int[] a={1,2,3};
        // Man[] mans = {new Man(1,1),new Man(2,2)};
        System.out.println("定义数组的同时就为数组元素分配空间并赋值" + a[1]); //打印数组因该不适用println
        System.out.println("定义数组的同时就为数组元素分配空间并赋值" + Arrays.toString(a)); //打印数组因该不适用println
        
        
        //动态初始化：数组定义、为数组元素分配空间、赋值的操作、分开进行
        int[] b = new int[2];
        b[0] = 1;
        b[1] = 2;
        // java中创建出了变量，但并没有赋值，系统会给他们默认赋值
        boolean[] c = new boolean[2];
        String [] s = new String[2]; //int类型的默认赋值为0
        System.out.println("boolean默认赋值："+c[0]+c[1]); //false
        System.out.println("String默认赋值："+s[0]+s[1]); // null

        
        // For-Each循环能在不使用下标的情况下遍历数组
       double[] mylist1 = {11.9,22.9,3.4,3.5};
        Arrays.sort(mylist1);
        System.out.println(" Arrays.sort()可以对列表排序"+Arrays.toString(mylist1));
        //二分法查找数组的索引
        System.out.println("该元素的索引："+Arrays.binarySearch(mylist1, 3.4)); //0;排序的结果作用在数组上

        
        //元素填充用full
        Arrays.fill(mylist1, 0,2, 100);//将0-2的元素替换为100
        System.out.println("元素填充用Arrays.full():"+Arrays.toString(mylist1));

       
        // 打印所有的数组元素
       for(double element:mylist1){
           System.out.println(element);
       }

       //将数组转化为列表
       int[] a12 = {3,5,1,9,7};
       List<int[]> list = Arrays.asList(a12);
       System.out.println(" Arrays.asList将数组转化为列表："+list);
       System.out.println(" return打印："+reverse(b));
       //多维数组的创建
       int a11[][] = new int[2][5];//初始化a11为2行2列
       //下方赋值给二维数组报错 Array constants can only be used in initializers
    //    a11[0] = {1,2};//报错：数组常量只能在初始化器中使用
    //二维数组赋值的话应该像矩阵一样数格子定位

    //    dataType[] arrayRefVar = new dataType[arraySize]; 创建数组但报错没有dataType类型
       //调用方法又怎么打印出来呢






       //我传入变量进去还报错：Index 2 out of bounds for length 2
    //    printArry(b);//好吧，方法传递的参数最好是变量
       reverse(b); //这里我同样不知道如何把变量赋值，list类型标记不是dataType[]么
    }
       //数组作方法入参
       public static void printArry(int[] array){
           for(int i=0;i<=array.length;i++){
               System.out.print(array[i]+"");//这是打印在一行
           }
       }

       //数组作返回值
       public static int[] reverse(int[] list){
           int[] result = new int[list.length];
           for(int i = 0,j = result.length-1;i<list.length;i++,j--){
               result[j] = list[i];//倒序列表 Arrays.asList将数组转化为列表
           }
           return result;
       }

    
}