Java_数组&&java.util.Arrays

当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0~n-1。数组的动态初始化，在定义数组的同时就为数组元素分配空间，数组一旦初始化，其长度是不可变的。数组是相同数据类型的多个元素的容器，元素按线性顺序排列，静

小企鹅推雪球!

4454人浏览 · 2020-05-19 15:33:38

小企鹅推雪球! · 2020-05-19 15:33:38 发布

文章目录

Java_数组
Java_数组的常见实例

Java_数组

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
在Java这种,数组是用来存储固定大小的同类型元素
Java中数组可以分为两类:
第一类按照维度：一维数组、二维数组、三维数组、…
第二类按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

Java_一维数组的基本概念

当需要在Java程序中记录单个数据内容时，则声明一个变量即可。
当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维数组即可，一维数组本质上就是在内存空间中申请一段连续的存储单元。
数组是相同数据类型的多个元素的容器，元素按线性顺序排列，在Java语言中体现为一种引用数据类型。
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址，并且数组的长度一旦确定，就不能修改。
可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0~n-1。
基本类型的数组（数据元素为基本类型）创建后，其元素的初始值如下：

基本类型默认值
byte、short、char、int、long 0
float和double 0.0
boolean false

基本类型	默认值
byte、short、char、int、long	0
float和double	0.0
boolean	false

数组的动态初始化，在定义数组的同时就为数组元素分配空间，数组一旦初始化，其长度是不可变的

语法格式：数据类型[] 数组名称 = new 数据类型[数组的长度];
int [] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
调用：length属性可以获取数组的长度
String names[];
names = new String[3];
// 在定义并用运算符new为数据分配空间后，才可以引用数组中的每个元素；
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";

数组的动态初始化
int [] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

String names[];
names = new String[3];
names[0] = "钱学森";
names[1] = "邓稼先";
names[2] = "袁隆平";

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int arr1[] = new int[]{ 3, 9, 8};
int[] arr2= {3,9,8};
String names1[] = {"张三","李四","华罗庚"};
// 数组元素的引用方式：`数组名[数组元素下标]`
// names1[1] = "张三";

Java_内存结构

内存结构之栈区：栈用于存放程序运行过程当中所有的局部变量。一个运行的Java程序从开始到结束会有多次变量的声明
内存结构之堆区：JVM会在其内存空间中开辟一个称为“堆”的存储空间，这部分空间用于存储使用new关键字创建的数组和对象。

Java_一维数组样例

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_数组的优缺点

优点：

可以直接通过下标(或索引)的方式访问指定位置的元素，速度很快。

缺点：

数组初始化以后，长度就不可变了，不便于扩展
数组要求内存空间连续，并且长度一旦确定就不能修改。
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。---->存储数据的特点单一

数组作为函数的参数

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_Arrays工具类

java.util.Arrays类即为操作数组的工具类，可以实现对数组中元素的遍历、查找、排序等操作。

常用方法	描述
static String toString(int[] a)	输出数组中的内容
static void fill(int[] a, int val)	将参数指定元素赋值给数组中所有元素
static boolean equals(boolean[] a, boolean[] a2)	判断两个数组元素内容和次序是否相同
static void sort(int[] a)	对数组中的元素进行从小到大排序
static int binarySearch(int[] a, int key)	从数组中查找参数指定元素所在的位置(二分法检索指定的值)

Java_二维数组

二维数组本质上就是由多个一维数组摞在一起组成的数组，二维数组中的每个元素都是一维数组，而一维数组中的每个元素才是数据内容。
多维数组就是看作数组的数组,比如二维数组就是一个特殊的一维数组,二维数组的每一个元素都是一个一维数组
创建一个二维数组str,str是一个三行四列的数组,从最高维开始为每一维分配空间

// 数据类型[][] 数组名称 = new 数据类型[行数][列数]; 
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("!");

//数据类型[][] 数组名称 = {{元素1, 元素2，...}, ...};
String [][] str = {{"Good","Good"},{"Luck","Luck"}}

JAVA_数组使用中常见的异常

数组下标越界异常(ArrayIndexOutOfBoundsException):发生情况

	int[] arr = new int[2];
	System.out.println(arr[2]);
	System.out.println(arr[-1]);
	// 访问到了数组中的不存在的脚标时发生。

空指针异常(NullPointerException)

	int[] arr = null;
	System.out.println(arr[0]);
	arr引用没有指向实体，却在操作实体中的元素时。

Java_System.arraycopy实现数组扩容

Java数组对象的大小是固定不变的,即数组对象是不可扩容的,但是利用数组复制的方法可以变通的实现数组扩容
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()实现数组扩容

使用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_数组的常见实例

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_使用工具类对数组排序

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_数组作为函数的参数

数组可以作为参数传递给方法

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] + " ");
        }
    }
}

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...