数组

最新推荐文章于 2021-02-15 15:02:23 发布
最新推荐文章于 2021-02-15 15:02:23 发布
阅读量298 收藏 1
点赞数
分类专栏： java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zenggeweiss/article/details/90242112
版权

一、数组概述和特点

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

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

建议：
   数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

二、数组声明和初始化

1、数组声明

【示例2-1】数组的声明方式有两种(以一维数组为例)

type[]   arr_name; //（推荐使用这种方式）
type    arr_name[];

注意事项：
  1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
  2. 声明一个数组的时候并没有数组真正被创建。
  3. 构造一个数组，必须指定长度。

【示例2-2】创建基本类型一维数组

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-1 基本类型数组内存分配图

【示例2-3】创建引用类型一维数组

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;//给引用类型数组元素赋值；
    }
}

在这里插入图片描述

图2-2 引用类型数组内存分配图

2、初始化

   数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三种方式分别讲解。

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

【示例2-4】静态初始化数组

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

2.动态初始化
   数组定义与为数组元素分配空间并赋值的操作分开进行。

【示例2-5】动态初始化数组

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

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

【示例2-6】数组的默认初始化

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

三、数组功能方法

1、数组的遍历

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

【示例3-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]);
        }
    }
}

   执行结果如图3-1所示：
在这里插入图片描述

图3-1 示例3-1运行效果图

2、for-each循环

   增强for循环for-each是JDK1.5新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。

【示例3-2】增强for循环

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

   执行结果如图3-2所示：
在这里插入图片描述

图3-2 示例3-2运行效果图

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

3、数组的拷贝

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

【示例3-3】数组拷贝

public class Test {
    public static void main(String args[]) {
        String[] s = {"阿里","尚学堂","京东","搜狐","网易"}; 
        String[] sBak = new String[6];
        System.arraycopy(s,0,sBak,0,s.length);
        for (int i = 0; i < sBak.length; i++) {
            System.out.print(sBak[i]+ "\t");
        }
    }
}

  执行结果如图3-3所示：
在这里插入图片描述

图3-3 示例3-3运行效果图

4、java.util.Arrays类

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

【示例3-4】打印数组

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)); // 打印数组元素的值；
    }
}

   执行结果如图3-4所示：
在这里插入图片描述

图3-4 示例3-4运行效果图

雷区：
  此处的Arrays.toString()方法是Arrays类的静态方法，不是前面讲的Object的toString()方法。

【示例3-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.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

   执行结果如图3-5所示：

在这里插入图片描述

图3-5 示例3-5运行效果图

【示例3-6】数组元素是引用类型的排序(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;
    }
}

【示例3-7】二分法查找

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)); 
    }
}

  执行结果如图3-6所示：

图7-8 示例7-13运行效果图.png

图3-6 示例3-7运行效果图

【示例3-8】数组填充

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));
    }
}

  执行结果如图3-7所示：
在这里插入图片描述

图3-7 示例3-8运行效果图

四、多维数组

  多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组(学习容器后，我们一般使用容器，二维数组用的都很少)。

【示例4-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];//非法
    }
}

【示例4-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-10 示例7-16内存分配图.png

图4-1 示例4-2内存分配图

【示例4-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]));
    }
}

   执行结果如图4-2所示：
在这里插入图片描述

图4-2 示例4-3运行效果图

【示例4-4】获取数组长度

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

五、数组存储表格数据

  表格数据模型是计算机世界最普遍的模型，可以这么说，大家在互联网上看到的所有数据本质上都是“表格”，无非是表格之间互相套用。如下表格是一张雇员表：

表5-1 雇员表

在这里插入图片描述
  我们观察表格，发现每一行可以使用一个一维数组存储：

Object[] a1 = {1001,"高淇",18,"讲师","2006-2-14"};
Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};

注意事项：

  此处基本数据类型”1001”，本质不是Object对象。JAVA编译器会自动把基本数据类型“自动装箱”成包装类对象。
  这样我们只需要再定义一个二维数组，将上面3个数组放入即可：

Object[][]  emps = new Object[3][];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;

【示例5-1】 二维数组保存表格数据

import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        Object[] a1 = {1001,"高淇",18,"讲师","2006-2-14"};
        Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
        Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};
        Object[][]  emps = new Object[3][];
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));  
    }
}

  执行结果如图5-1所示：
在这里插入图片描述

图5-1 示例5-1运行效果图

六、冒泡排序

1、冒泡排序的基础算法

   冒泡排序是最常用的排序算法，在笔试中也非常常见，能手写出冒泡排序算法可以说是基本的素养。
   算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：

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

在这里插入图片描述

图6-1 身高图

【示例6-1】冒泡排序的基础算法

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;
                }
            }
        }
    }
}

   执行结果如图6-2所示：
在这里插入图片描述

图6-2 示例6-1运行效果图

2、冒泡排序的优化算法

  其实，我们可以把6.1的冒泡排序的算法优化一下，基于冒泡排序的以下特点：
  1.整个数列分成两部分：前面是无序数列，后面是有序数列。
  2.初始状态下，整个数列都是无序的，有序数列是空。
  3.每一趟循环可以让无序数列中最大数排到最后，(也就是说有序数列的元素个数增加1)，也就是不用再去顾及有序序列。
  4.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可(而不是数列的末尾);如果前一个大于后一个，交换。
  5.判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了。此时可以中止比较。

【示例6-2】冒泡排序的优化算法

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;
            }
        }
    }
}

  执行结果如图6-3所示：
在这里插入图片描述

图6-3 示例6-2运行效果图

七、二分法查找

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

在这里插入图片描述

图7-1 二分法示意图

【示例7-1】二分法查找

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
    }
}

执行结果如图7-2所示：
在这里插入图片描述

图7-2示例7-1运行效果图

Java学习总结
梦见另一个夏夜，一颗星的葬礼
01-07 2277
0 Java语言概述 0.1 Java的特点 面向对象，Java程序“一切都在类中”，支持继承、多态机制 语法来自C++，取消了指针，多重继承和运算符重载，设立了自动内存回收机制，提供丰富类库 跨平台，一遍编译，到处执行 Java程序具有半编译，半解释的特性，由编译器将源程序编程成字节码文件，再由JVM将字节码文件解释执行。比解释性语言的执行效率高，比编译型语言更具灵活性（可移植） 支持分布式（数据分布和操作分布） 引入多级安全措施（内存使用、字节码验证器） 支持多线程 0.
Java冒泡排序代码
03-05
package JavaClassTest1; //测试冒泡排序 /********************* * int[] num = {23,45,76,78,98,54,}; 第一次 23 45 76 78 54 98 第二次 23 45 76 54 78 98 第三次 23 45 54 76 78 98 输出 ：23 45 54 76 78 98 当判断为正确时就退出循环 *********************/ public class TestMaoPaoPaiXu { public static void main(String[] args) { //Scanner reader = new Scanner(System.in); // int[] num = {3,4,6,8,9}; int[] num = {23,45,76,78,98,54,}; // for(int a : num) { // System.out.print(a + " "); // } // System.out.println(); boolean flog = true; for(int i = 1;i < num.length&&flog;i++) { //num.length个元素，终须只需循环num.length-1次 flog = false; for(int j = 0;j num[j + 1]) {////注意此处不是i，而是j，如果是i，会提示越界 int s= num[j]; num[j] = num[j + 1]; num[j + 1] = s; flog = true; } } for(int a : num) //注意这个输出for语句放在外层for里面 System.out.print(a + " "); System.out.println(); } } }
Java学习从入门到精通
ForeverSeaStar的专栏
04-04 1526
Java学习从入门到精通[转贴] Java Learning Path （一）、工具篇一、 JDK (Java Development Kit)JDK 是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握 JDK是学好Ja
java冒泡排序代码
weixin_30270889的博客
10-24 104
1 public class MaoPaoSort { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 int a[] = { 10, 8, 12, 5, 4 }; 8 int temp; 9...
lotus domino 数组使用归纳总结
03-03
Lotus Domino是一款强大的协同软件平台，它提供了丰富的编程接口，其中数组是进行数据处理和逻辑控制的重要工具。本文将深入探讨Lotus Domino中数组的使用，包括数组的创建、操作和常见应用。 一、数组的基本概念 ...
matlab初始化数组
11-16
Matlab 字符串数组和结构数组的创建、运算和操作 Matlab 中的字符串数组和结构数组是进行复杂编程的基础。字符串数组主要用于可视化编程内容，如界面设计和图形绘制。在 Matlab 中，字符串数组可以通过单引号创建，...
Javscript删除数组中指定元素并返回新数组
12-11
在JavaScript中，数组是一种常用的数据结构，用于存储一系列有序的元素。在处理数组时，有时我们需要根据特定条件从数组中删除元素。这个场景下，我们可以自定义一个方法来实现删除指定元素并返回新数组的功能。这里...
PHP实现一维数组转二维数组的方法
10-24
要将一维数组转换为二维数组，我们需要遍历一维数组，然后将每个元素插入到新的二维数组中作为一个新数组。以下是一个简单的实现方法： ```php // 原始一维数组 $asr[1] = array("a", "b", "c", "d"); $asr[2] = ...
java学习总结
07-15
java重点理解，学习总结及要求：数据类型（基本数据类型，也称为非对象类型；对象类型，引用类型（数组引用，类引用，接口引用）、、、
JAVA学习总结
qq_38875218的博客
11-17 460
JAVA学习总结day1-day4 文章目录 一、JVM、JRE、JDK的作用，区别及关系 1.JVM是JAVA虚拟机，是让JAVA语言程序可以在不同平台进行运行的程序，JVM虚拟机本身不允许跨平台，允许跨平台的是JAVA语言。 2.JRE是Java Runtime Environment的缩写，是指JAVA的运行环境，包含JVM虚拟机以及JAVA核心类库。 3.JDK是JAVA语言的软件开发工具包，内部包含了代码的编译和运行工具。 4.三者的作用： - 编写代码的过程中，使用JRE中JAV.
java学习总结（一）
qq_42260635的博客
11-02 861
1.关键字、标识符、注释 //关键字：在JAVA中对某些单词赋予了特殊功能，他们就成java中的关键字（以红色标识） //package,import,public,class,static,void,new... //标识符：给类，变量，接口起的名字，称为一个标识符 //day1.part2(包名)，Demo1（类名），main（方法名），args（变量名） //类开头（大写），标识符（小写...
java 冒泡 排序代码_Java冒泡排序
weixin_39608300的博客
02-15 395
版权声明：转载原创文章请以超链接形式请注明原文章出处，尊重作者，尊重原创！恰饭广告先贴出代码(从小到大排序)：public class BubbleSort {public static void main(String args[]){double[] a={0,1,5,9,10,2,4,6,3,7,8,-3,0.4,-2.5};for (int i=0;ifor (int j=0;jif (a...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值