JAVA学习整理——数组

最新推荐文章于 2022-07-06 15:14:00 发布
最新推荐文章于 2022-07-06 15:14:00 发布
阅读量222 收藏
点赞数
分类专栏： JAVA 文章标签： 数组 JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44478494/article/details/89248087
版权

1.数组概述

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。数组的三个基本特点：

  1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
  2. 其元素必须是相同类型，不允许出现混合类型。
  3. 数组类型可以是任何数据类型，包括基本类型和引用类型。

2.数组声明

//声明方法一
int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
//声明方法二
 int[] s = null; // 声明数组；
        s = new int[10];

2.1 基本类型一维数组

public class Test {
    public static void main(String args[]) {
        int[] s = null; // 声明数组；
        s = new int[10]; // 给数组分配空间；
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;//给数组元素赋值；
            System.out.println(s[i]);
        } 
    }
}

基本类型数组内存分配图

2.2 引用类型一维数组

class Man{
    private int age;
    private int id;
    public Man(int id,int age) {
        super();
        this.age = age;
        this.id = id;
    }
}
public class AppMain {
    public static void main(String[] args) {
        Man[] mans;  //声明引用类型数组； 
        mans = new Man[10];  //给引用类型数组分配空间；
   
        Man m1 = new Man(1,11);
        Man m2 = new Man(2,22);  
         
        mans[0]=m1;//给引用类型数组元素赋值；
        mans[1]=m2;//给引用类型数组元素赋值；
    }
}

引用类型数组内存分配图

3.数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

3.1静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

3.2动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

3.3默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

4.数组遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

public class Test {
    public static void main(String[] args) {
        int[] a = new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
        //读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

JDK1.5后新增功能增强for循环（for-each），专门用于读取数组或集合中所有的元素，即对数组进行遍历。
代码示例如下：

public class Test {
    public static void main(String[] args) {
        String[] ss = { "aa", "bbb", "ccc", "ddd" };
        for (String temp : ss) {
            System.out.println(temp);
        }
    }
}

备注

  1. for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。
  2. for-each仅适用于遍历，不涉及有关索引(下标)的操作。

5.数组拷贝/删除/扩容

System类里也包含了一个static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。

5.1数组之间拷贝

	//测试数组之间的拷贝
	public static void testBasicCopy(){
		String[]s1={"aa","bb","cc","dd","ee"};
		String[]s2=new String[10];
		//从s1的s1[2]开始拷贝三个数据存储到s2[6]
		System.arraycopy(s1, 2, s2, 6, 3);
		for(int i=0;i<s2.length;i++){
			System.out.println(i+"--"+s2[i]);
		}
	}

输出结果：在这里插入图片描述

5.2删除某个元素

  //删除数组中指定索引位置的元素，并将原数组返回,删除s[index]
    public static String[] removeElment(String[] s,int index){
    	
    	System.arraycopy(s, index+1, s, index, s.length-index-1);
  	    s[s.length-1]=null;
  	    for(int i=0;i<s.length;i++){
			System.out.println(i+"--"+s[i]);
		}
  	    return s;
	}

5.3数组扩容

 //数组的扩容（本质上：先定义一个更大的数组，然后将原数组内容拷贝到新数组中）
    public static void extendRange(String[]s1){
    	String[]s2=new String[s1.length+10];
    	//将s1中所有元素拷贝到s2中
    	System.arraycopy(s1, 0, s2, 0, s1.length);
    	for(int i=0;i<s2.length;i++){
    		System.out.println(s2[i]);
    	}    	
    }

6.java.util.Arrays类

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

6.1打印数组

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

6.2数组元素的排序

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);    //排序
        System.out.println(Arrays.toString(a));
    }
}

6.3引用类型的排序(Comparable接口的应用)

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        Man[] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
        Arrays.sort(msMans);
        System.out.println(Arrays.toString(msMans));
    }
}
 
class Man implements Comparable {
    int age;
    int id;
    String name;
 
    public Man(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
 
    public String toString() {
        return this.name;
    }
 
    public int compareTo(Object o) {
        Man man = (Man) o;
        if (this.age < man.age) {
            return -1;
        }
        if (this.age > man.age) {
            return 1;
        }
        return 0;
    }
}

6.4二分法查找

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序;
        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12)); 
    }
}

6.5数组填充

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] a= {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100);  //将2到4索引的元素替换为100;
        System.out.println(Arrays.toString(a));
    }
}

7.多维数组

简单的讲，多维数组就是数组的数组，数组的每个元素都是一维数组。

7.1二维数组的声明

public class Test {
    public static void main(String[] args) {
        // Java中多维数组的声明和初始化应按从低维到高维的顺序进行
        int[][] a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        // int a1[][]=new int[][4];//非法
    }
}

7.2二维数组的静态初始化

public class Test {
    public static void main(String[] args) {
        int[][] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
        System.out.println(a[2][3]);
    }
}

在这里插入图片描述

7.3二维数组的动态初始化

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[][] a = new int[3][];
        // a[0] = {1,2,5}; //错误，没有声明类型就初始化
        a[0] = new int[] { 1, 2 };
        a[1] = new int[] { 2, 2 };
        a[2] = new int[] { 2, 2, 3, 4 };
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}

7.4获取数组长度

//获取的二维数组第一维数组的长度。
System.out.println(a.length);
//获取第二维第一个数组长度。
System.out.println(a[0].length);

8.冒泡排序

算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。

8.1排序思路

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

8.2基础算法

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }
 
    public static void bubbleSort(int[] values) {
        int temp;
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < values.length - 1 - i; j++) {
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                }
            }
        }
    }
}

8.3优化算法

优化内容：
判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了。此时可以中止比较。

import java.util.Arrays;
public class Test1 {
    public static void main(String[] args) {
        int[] values = { 3, 1, 6, 2, 9, 0, 7, 4, 5, 8 };
        bubbleSort(values);
        System.out.println(Arrays.toString(values));
    }
    public static void bubbleSort(int[] values) {
        int temp;
        int i;
        // 外层循环：n个元素排序，则至多需要n-1趟循环
        for (i = 0; i < values.length - 1; i++) {
            // 定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag = true;
    /*内层循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后*/
            for (int j = 0; j < values.length - 1 - i; j++) {
                // 如果前一个元素大于后一个元素，则交换两元素的值；
                if (values[j] > values[j + 1]) {
                    temp = values[j];
                    values[j] = values[j + 1];
                    values[j + 1] = temp;
                       //本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
                    flag = false;
                }
            }
           //根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
            if (flag) {
                break;
            }
        }
    }
}

9.二分法查找

9.1思路

二分法检索(binary search)又称折半检索，二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组(array)中，首先将给定值key与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功;
否则，若key小，则在数组前半部分中继续进行二分法检索；
若key大，则在数组后半部分中继续进行二分法检索。
这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。
二分法检索是一种效率较高的检索方法。

9.2代码

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        int[] arr = { 30,20,50,10,80,9,7,12,100,40,8};
        int searchWord = 20; // 所要查找的数
        Arrays.sort(arr); //二分法查找之前，一定要对数组元素排序
        System.out.println(Arrays.toString(arr));
        System.out.println(searchWord+"元素的索引："+binarySearch(arr,searchWord));
    }
 
    public static int binarySearch(int[] array, int value){
        int low = 0;
        int high = array.length - 1;
        while(low <= high){
            int middle = (low + high) / 2;
            if(value == array[middle]){
                return middle;         //返回查询到的索引位置
            }
            if(value > array[middle]){
                low = middle + 1;
            }
            if(value < array[middle]){
                high = middle - 1;
            }
        }
        return -1;     //上面循环完毕，说明未找到，返回-1
    }
}
博客写的好晚上睡得早
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数组笔记整理
kY_98的博客
03-27 456
数组 一维数组 1.什么是数组？ 数组是一个特殊的“变量”，存储相同类型的一组数据。 比如声明一个一个变量就是在内存空间划出一块适合的空间，声明一个数组就是在内存空间划出一串连续的空间。 变量是在内存中临时存储的运行数据 为了能够更复杂的存储数据,我们需要学习数组 数组和变量在内存中存储的对比效果图： 数组和变量一样，由四种要素组成 数组的基本要素： 1.标识符 和变量名命名规范一致 2.数组...
Java数组知识整理
笑笑是一个码农
07-19 1357
一、数组的概念 数组是相同数据类型元素的集合。 数组本身是引用数据类型，但它可以存储基本数据类型和引用数据类型。 二、数组的声明 语法一：数据类型[] 数组名; 语法二：数据类型 数组名[]; 三、数组的创建 两个要素：数据类型、长度。 语法一：数据类型[] 数组名 = new 数据类型[长度];(动态初始化，先定义数组，然后初始化数据) 语法二：数据类型[] 数组名 = new...
Java 数组整理
T Yuan
03-28 381
二维数据int [][] at = new int [10][10]; //第二维数组定长 int [][] bt = new int [10][]; //第二维数组变长 for (int i = 0; i < bt.length; i++) { bt[i] = new int [i + 1]; }
Java数组整理
Zengqh-0417
02-06 156
输入数据 Scanner类 Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，获取到录入的数据。 Scanner使用步骤： 导包： import java.util.Scanner; 创建对象实例： Scanner sc = new Scanner(System.in); 调用方法： int i = sc.nextInt(); 用来接收控制台录入的数字 String s = sc.next(); 用来接收控制台录入的字符串 import java.util.Scanner;
Java知识点整理(数组)
weixin_54913875的博客
04-11 623
数组是什么,就是保存很多数据类型相同的元素放到一个容器,这个容器就叫做数组. 1.声明方式 int[] arr = {元素};只有在明确知道元素是什么才可以用此声明方法! int[] arr = new int[长度];元素类型任意,但是长度一定要知道或者赋予长度 2.特点: 数组一旦声明长度不可变!!!!! 线性结构,具备索引,索引从0开始!数据库除外(暂时不同管知道就行) 3.基本取值和赋值: 在[]里面使用运算符,加索引在数组里对特定的空间进行取值和赋值 4.数组遍历:
Java语言程序设计讲义——数组与字符串
12-17
这一款整理发布的Java语言程序设计讲义——数组与字符串，适用于日常学习、参考、借鉴Java语言...该文档为Java语言程序设计讲义——数组与字符串，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以下载看看
JAVA核心知识点整理——java自学资料.rar
08-03
这份"JAVA核心知识点整理——java自学资料.rar"包含了一份详细的Java学习资源，旨在帮助已经具备一定Java基础知识的开发者进一步提升技能，深入理解Java的底层机制。以下是这份资料可能涵盖的一些核心知识点和学习...
Java学习笔记——良葛格
09-15
【Java学习笔记——良葛格】是一份由爱好者良葛格整理的Java学习资料，主要以PDF格式呈现，虽然可能不完整，但包含了丰富的Java编程基础知识和实践技巧，旨在为初学者提供一个学习和参考的平台。以下是笔记中可能...
_Java学习材料(499篇文章)等自己整理的资料——.rar_java
09-23
这份压缩包中的"Java学习材料(499篇文章)等自己整理的资料——.rar"显然是一个精心收集的资源集合，涵盖了Java的学习路径，从基础到进阶，包括面试准备和编程规范。 首先，让我们来探讨Java的基础部分。JavaSE...
JAVA核心知识点整理.pdf
最新发布
03-15
Java的动态多态性依赖于方法的绑定机制——晚期绑定（Late Binding），也叫虚方法调用。 JVM（Java虚拟机）是Java程序运行的基础，它负责解析并执行字节码，提供了线程支持、内存管理等服务。JVM内存区域可以分为...
java数组集合分类整理
qq_33716688的博客
06-30 258
package dataStructure; import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl; import java.lang.reflect.Array; import java.util.*; /** * 集合 * * @since 2020-06-30 */ public class ListDemo { public static void main(String[] args) { .
java定义并赋值_在Java语言中，下列对于字符数组的定义并赋值正确的是（选一项）...
weixin_33050129的博客
02-20 369
在Java语言中，下列对于字符数组的定义并赋值正确的是(选一项)更多相关问题在WindowsXP支持下，用户操作计算机系统的基本工具是()。A.鼠标器B.键盘C.键盘和鼠标器关闭一个活动应用程序窗口，可以按快捷键()。A.Ctrl＋EscB.Ctrl＋F4C.Alt＋F4D.Alt＋Esc剪贴板是()中一块临时存放交换信息的区域。A.ROMB.RAMC.硬盘WindowsXP中，欲选定当前文件夹中...
04 数组习题的整理
weixin_47453375的博客
07-06 287
数组习题 1查找单词 2提取元素生成新数组 3判断今年是第多少天（闰年加1计算）
JAVA300第七章数组作业
Jeloys的博客
05-08 1239
一、选择题 1. 在Java中，以下程序段能正确为数组赋值的是(ACD)。 A. int a[]={1,2,3,4}; B. int b[4]={1,2,3,4}; C. int c[]; c=new int[] {1,2,3,4}; D. int d[];d=new int[]{1,2,3,4}; 2. 已知表达式int [] m={0,1,2,3,4,5,6};下面( )表达式的值与数...
Java数组练习题
张子又
12-09 2225
定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。 public class Test { // 思路：遍历数组时当有值与输入字符串相同时使用一个boolean记录状态 public static void main(String[] args) { Strin...
数组查找操作：定义一个长度为10 的一维字符串数组，在每一个 元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“N”。
peiwen_java的博客
12-02 893
为数组分配空间并赋值 定义布尔类型并输出
数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词
码走江湖的博客
08-31 9413
数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。 import java.util.Scanner; public class Array { public static void main(String[] args) { ...
经常考的String与数组中的问题
yZzc_XQ的博客
03-27 266
经常考的String与数组中的问题 下面这道题，我相信你肯定很熟悉，但是做了这么多遍是不是还是很疑惑呢？耐心看完，你不会后悔的。 public class Example{ String str = new String("good"); char[ ] ch = { 'a' , 'b' , 'c' }; public static void main(Strin...
leetcode d面试题56 - I. 数组中数字出现的次数
fang156239305的博客
06-01 264
面试题56 - I. 数组中数字出现的次数 难度中等151 一个整型数组nums里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 示例 1： 输入：nums = [4,1,4,6] 输出：[1,6] 或 [6,1] 示例 2： 输入：nums = [1,2,10,4,1,4,3,3] 输出：[2,10] 或 [10,2] class Solution: def singleNumbers(se...
Java多维数组学习与编程资源
"多维数组-java 学习 资源" Java中的多维数组是一种强大的数据结构，它允许存储和操作二维或更高维度的数据。在Java中，多维数组被理解为数组的数组，这意味着每个数组元素本身可以是另一个数组。这种特性使得多维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值