Java_数组

Posted 小企鹅推雪球!

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java_数组相关的知识，希望对你有一定的参考价值。

文章目录

Java_数组

  1. 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
  2. 在Java这种,数组是用来存储固定大小的同类型元素
  3. Java中数组可以分为两类:
  4. 第一类按照维度：一维数组、二维数组、三维数组、…
  5. 第二类按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)
  6. 数组常见的概念:数组名,下标(索引),元素,长度
  7. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括
    基本数据类型和引用数据类型。
  8. 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是
    这块连续空间的首地址。
  9. 数组的长度一旦确定，就不能修改。
  10. 可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

Java_声明数组

  1. 必须先声明数组,才能在程序中使用数组, 声明方式：type var[] 或 type[] var；,例如int a[];int[] a1;double b[];
  2. String[] c;//引用类型变量数组
  3. Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

Java_一维数组的使用

  1. 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
  2. int[] arr = new int[3];创建了一个名为arr的数组,包含了3个int类型元素
  3. 数组下标是从0开始的
 int[] arr = new int[3];
	arr[0] = 3;
	arr[1] = 9;
	arr[2] = 8;

String names[];
names = new String[3];
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”
  1. 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
  2. int arr[] = new int[]{ 3, 9, 8};或int[] arr = {3,9,8}
  3. String names[] = {“张三”,“李四”,“华罗庚”}

数组样例

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

Java_数组元素的使用

  1. 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
  2. 数组元素的引用方式：数组名[数组元素下标]
  3. 数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i]
  4. 数组元素下标从0开始；
  5. 长度为n的数组合法下标取值范围:0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
  6. 每个数组都有一个属性length指明它的长度，例如：a.length指明数组a的长度(元素个数)
  7. 数组一旦初始化，其长度是不可变的
  8. 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
    例如：
public class Test {
	public static void main(String argv[]){
		int a[]= new int[5];
		System.out.println(a[2]); //a[2]的默认值为0
	}
}
  1. 对于基本数据类型而言，默认初始化值各有不同
  2. 对于引用数据类型而言，默认初始化值为null(注意与0不同！)

Java_数组作为函数的参数

  1. 数组可以作为参数传递给方法
package com.company;
// 数组作为函数的参数传递给方法
// 遍历数组成员
public class Java_07 {
    public static void main(String[] args) {
        printArray(new int[]{3, 1, 2, 6, 4, 2});
    }
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int temp = i+1;
            System.out.println("第"+temp +"个成员"+array[i] + " ");
        }
    }
}

Java_多维数组

  1. 多维数组就是看作数组的数组,比如二维数组就是一个特殊的一维数组,二维数组的每一个元素都是一个一维数组

创建多维数组:
String str[][] = new String[2][3];

  1. 创建一个二维数组str,str是一个三行四列的数组
  2. 从最高维开始为每一维分配空间
String str[][] = new String[2][3];
str[0][0] = new String("Good");
str[0][1] = new String("Luck");
str[1][0] = new String("to");
str[1][1] = new String("you");
str[1][2] = new String("!");

Java_Arrays工具类的使用

  1. java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比
    如排序和搜索）的各种方法。
  2. boolean equals(int[] a,int[] b) 判断两个数组是否相等。
  3. String toString(int[] a) 输出数组信息。
  4. void fill(int[] a,int val)将指定值填充到数组之中。
  5. void sort(int[] a) 对数组进行排序。
  6. int binarySearch(int[] a,int key)对排序后的数组进行二分法检索指定的值。

JAVA_数组使用中常见的异常

  1. 数组脚标越界异常(ArrayIndexOutOfBoundsException):发生情况
	int[] arr = new int[2];
	System.out.println(arr[2]);
	System.out.println(arr[-1]);
	// 访问到了数组中的不存在的脚标时发生。
  1. 空指针异常(NullPointerException)
	int[] arr = null;
	System.out.println(arr[0]);
	arr引用没有指向实体，却在操作实体中的元素时。

Java_System.arraycopy实现数组扩容

  1. Java数组对象的大小是固定不变的,即数组对象是不可扩容的,但是利用数组复制的方法可以变通的实现数组扩容
  2. System.arraycopy()可以复制数组,简单实现数组扩容
package com.company;

import java.util.Arrays;

// 数组扩容
public class Java_09 {
    public static void main(String[] args) {
        String[] name = new String[] { "A", "B", "C" };
        String[] nameK = new String[5];
        nameK[3] = "D";
        nameK[4] = "E";
        // 使用 System.arraycopy 变通的实现数组扩容 复制数组
        System.arraycopy(name, 0, nameK, 0, name.length);
        for (String str : nameK){
            System.out.println("扩容后");
            System.out.println(str);
        }

     
    }
}

Java_Arrays.copyOf()实现数组扩容

  1. 使用Arrays.copyOf()将一个数组的值完整覆盖给另一个数组,再设置新的数组大小来是新数组扩容
package com.company;

import java.util.Arrays;
// 使用 Arrays.copyOf实现数组扩容
public class Java_10 {
    public static void main(String[] args) {
        int a[] = {4, 3, 6, 5, 1, 2};
        int b[] = Arrays.copyOf(a, 4);
        int c[] = Arrays.copyOfRange(a, 2, 4 + 1);

        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " ");
            System.out.println();

        for (int i = 0; i < c.length; i++)
            System.out.print(c[i] + " ");
            System.out.println();

// Arrays.copyOf的两种方式
//        Arrays.copyOf(array, to_index);
//        Arrays.fill(array, from_index, to_index);
    }
}

Java_数组在内存存储方面的特点

  1. 数组初始化以后，长度就确定了。
  2. 数组声明的类型，就决定了进行元素初始化时的类型

Java_数组存储数据的弊端

  1. 数组初始化以后，长度就不可变了，不便于扩展
  2. 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
  3. 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

Java_数组的常见实例

Java_冒泡排序

package com.company;

import java.util.Arrays;

// 数组的冒泡排序
public class Java_11 {
    public static void main(String[] args) {
        int [] a = {1,3,5,1,5,1,5,54,1,484,1,8,848,5,};
        mySort(a);
    }



    // 数组的冒泡排序
    // 1. 比较数组中,两个相邻元素,如果第一个数比第二个数大,那么交换他们的顺序
    // 2. 每一次比较，都会产生出一个最大，或者最小的数字；
    // 3.下一轮则可以少一次排序！
    // 4.依次循环，直到结束！

    public static void  mySort(int[] arr){
        int num;
        int count = 0;
        for(int i = 0;i<arr.length-1;i++){
            for(int j = 0;j <arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    num = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = num;
                    count = count +1 ;
                }
            }
            if(count == 0){
                break;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

Java_选择法排序

package com.company;

import java.util.Arrays;

// 选择法排序
public class Java_12 {
    public static void main(String[] args) {
        int arr[]= {23,12,48,56,45};
        for(int i=0;i<arr.length;i++) {
            int tem=i;
            //将数组中从i开始的最小的元素所在位置的索引赋值给tem
            for(int j=i;j<arr.length;j++) {
                if(arr[j]<arr[tem]) {
                    tem=j;
                }
            }
            //上面获取了数组中从i开始的最小值的位置索引为tem，利用该索引将第i位上的元素与其进行交换
            int temp1=arr[i];
            arr[i]=arr[tem];
            arr[tem]=temp1;
        }
        System.out.println(Arrays.toString(arr));
    }

}

Java_直接插入法排序

package com.company;

import java.util.Arrays;

// 直接插入排序 将数组中最大的值放置在最后面
public class Java_14 {
    public static void main(String[] args) {

        int []arr={23,12,48,56,45};
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j - 1] > arr[j]) {//大的放后面
                    int tmp = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

Java_使用工具类对数组排序

  1. java.util.Arrays类的sort()方法提供了数组元素排序功能：
import java.util.Arrays;
public class SortTest {
	public static void main(String[] args) {
		int [] numbers = {5,900,1,5,77,30,64,700};
		Arrays.sort(numbers);
		for(int i = 0; i < numbers.length; i++){
			System.out.println(numbers[i]);
		}
	}
}

以上是关于Java_数组的主要内容，如果未能解决你的问题，请参考以下文章

Java经典安全数组实现的代码

java.io.ByteArrayInputStream

web代码片段

错误代码：错误域 = NSCocoaErrorDomain 代码 = 3840“JSON 文本没有以数组或对象和允许未设置片段的选项开头。”

javascript常用代码片段

常用Java程序片段