首页 / JAVA / JavaSE进阶数组

JavaSE进阶数组

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了JavaSE进阶数组，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10360字，纯文字阅读大概需要15分钟。

内容图文

一维数组

概述

Java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。
数组实际上是一个容器，可以同时容纳多个元素（数组是数据的集合）
元素的类型要统一
数组中的元素内存地址是连续的
数组中可以存储“基本数据类型”和“引用数据类型”（对象的引用，即内存地址，4个字节长度）的数据
因为数组是引用数据类型，所以数组对象是在堆内存当中（数组存储在堆内存当中）
数组一旦创建，在java中规定，长度不可变（数组长度不可变）
所有数组对象都有length属性（java自带的），用来获取数组中的元素个数
数组是一种数据结构
所有数组都是将首元素的内存地址作为自己的内存地址
数组中的每一个元素都有下标，下标从0开始，以1递增，最后一个元素的下标是：length-1

特点总结：连续、统一、不变

内存结构图

JavaSE进阶数组 - 文章图片

优点

每一个元素的内存地址在空间储存上是连续的
每一个元素类型相同，所以占用空间大小一样
知道第一个元素内存地址,知道每一个元素占用空间的大小,又知道下标,所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最髙的。

数組中存储100个元素,或者存储100万个元素,在元素査询/检索方面,效率是相同的,因为数組中元素査找的肘候不会一个一个找，是通过数学表达式计算出来的。

缺点

由于为了保证数组中每个元素的内存地址连续,所以在数纽上随机删除或者増加元素的时候,效率较低,因为随机増删元素会涉及到后面元素统一向前或者向后位移的操作。
数组不能存储大數据量,因为很难在内存空间上找到一块特别大的连续的内存空闾。

注意:对于数组中最后一个元素的増删,是没有效率形响的。

声明/定义

Java风格
int[] array01;
c++的方式，不建议
int array01[];

eg.main方法中的参数
String[] args或者
String args[]

初始化

静态初始化

int[] array01={1,2,3,4,5};

动态初始化

int[] array01=new int[5];
每个元素默认值是0
String[] array02=new String[5];
每个元素默认值是null

当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式，不确定的时候，采用动态初始化，预先分配内存空间

遍历数组

int[] a={1,2,3,4,5};
//从第一个元素开始遍历
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}
//从最后一个开始遍历
for(int i=a.length-1;i>=0;i--){
    System.out.println(a[i]);
}

方法参数是数组

public class ArraysTest01 {
    public static void main(String[] args) {

        int[] a={1,2,3};
        printArray(a);

        System.out.println("-------------");
        printArray(new int[3]);

        System.out.println("-------------");
        printArray(new int[]{6,7,8});

    }
    public static void printArray(int[] array){
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }
}

结果：

JavaSE进阶数组 - 文章图片

解析mian方法参数

“String[ ] args”有什么作用？JVM调用main方法时，会自动传一个String数组过来，主要用来接收用户输入参数的。

这个数组什么时候里面会有值呢?其实这个数组是留给用户的，用户可以在控制台上输入参数，这个参数自动会披转换为"String[ ] args" 。例如这样运行程序∶java ArrayTest05 abc def xyz，那么这个时候JVM会自动将abc def xyz通过空格的方式进行分离，分离完成之后，自动放到“String[ ] args”数组。（把abc def xyz转换成字符串数组：{“abc”，“def”，“xyz”}）

public class ArraysTest02 {
    public static void main(String[] args) {

        //这里测试得出两个结论
        //1.args数组长度默认值为0
        //2.args不为null,可能JVM内部已进行初始化
        System.out.println("args数组长度为"+args.length);

        String[] strs={ };
        printLength(strs);

        for(int i=0;i< args.length;i++){
            System.out.println(args[i]);
        }

    }
    public static void printLength(String[] array){
        System.out.println("strs数组长度为"+array.length);
    }
}

怎么在IDEA中传入abc、def、xyz等参数? run→edit configuration→在Program arguments上打上abc、edf、xyz，结果如下：

JavaSE进阶数组 - 文章图片

实际应用：模拟一个系统，假设这个系统要使用，必须输入用户名和密码

public class ArrayTest03 {

    public static void main(String[] args) {

        if(args.length!=2){
            System.out.println("要使用此系统，必须输入用户名和密码，如 zhangsan 123");
            return;
        }

        //程序执行到这里说明正确输入了信息
        //取出用户名
        String username=args[0];
        //取出密码
        String password=args[1];
        //表示用户名为admin，密码是123时登录成功，其他一律失败
        //username.equals("admin")&&password.equals("123")
        //以下写法能避免空指针异常
        if("admin".equals(username)&&"123".equals(password)){
            System.out.println("登录成功，欢迎["+username+"]回来");
            System.out.println("您可以继续使用该系统....");
        }else{
            System.out.println("验证失败，用户名不存在或者密码错误！");
        }
    }
}

存储引用数据类型

public class ArraysTest04 {

    public static void main(String[] args) {

        Bird a1=new Bird();
        Cat a2=new Cat();
        Plant a3=new Plant();
        //能放子类，放不了Plant类
        Animal[] ans= {a1,a2};
        //Animal中没有Scratch()方法
        //ans[0].Scratch();
        for(int i=0;i< ans.length;i++){
            if(ans[i] instanceof Cat){
                Cat cat=(Cat)ans[i];
                cat.scratch();
            }else if(ans[i] instanceof Bird){
                Bird bird=(Bird)ans[i];
                bird.sing();
            }
        }

    }
}
class Animal{
    public void move(){
        System.out.println("Animal is moving.");
    }
}

class Cat extends Animal{
    @Override
    public void move() {
        System.out.println("Cat is walking");
    }
    public void scratch(){
        System.out.println("疯狂乱抓");
    }
}
class Bird extends Animal{
    @Override
    public void move() {
        System.out.println("Bird is flying.");
    }
    public void sing(){
        System.out.println("Bird is sing songs.");
    }
}

class Plant{
    public void absorb(){
        System.out.println("Plant is obsorbing CO2");
    }
}

数组扩容

在java开发中，数组长度一旦确定不可变，那么数组满了时需要扩容。 java中对数组的扩容是∶先新建—个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大数组当中。

结论：数组扩容效率较低。印为涉及到拷贝的问题。所以在以后的开发中请注章∶尽可能少的进行数组的拷贝。可以在创建数组对象的时候预估计一下多长合适，最好预估准确，这样可以减少数组的扩容次数。提高效率。

JavaSE进阶数组 - 文章图片

public class ArraysTest05 {
    public static void main(String[] args) {

        //数组拷贝
        //拷贝源
        int[] src={1,11,22,3,4};
        //拷贝目标
        int[] dest=new int[20];//动态初始化，每个元素默认值为0

        //调用JVM System类中的arraycopy方法，来完成数组的拷贝
        System.arraycopy(src,1,dest,3,2);

        for(int i=0;i< dest.length;i++){
            System.out.println(dest[i]);  //0 0 0 11 22 ... 0
        }
        //完全拷贝
        System.arraycopy(src,0,dest,0,src.length);

        Object[] obj={new Object(),new Object(),new Object()};
        Object[] newObj=new Object[5];
        //这里拷贝的是对象的地址，而不是对象
        System.arraycopy(obj,0,newObj,0,obj.length);

        for(int i=0;i< newObj.length;i++){
            System.out.println(newObj[i]);
            //java.lang.Object@16b98e56 java.lang.Object@7ef20235 java.lang.Object@27d6c5e0...null
        }
    }
}

JavaSE进阶数组 - 文章图片

二维数组

二维数组其实是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。三维数组是一个特殊的二维数组，特殊在这个二维数组中每一个元素是一个一维数组。

遍历

public class ArraysTest06 {
    public static void main(String[] args) {

        //静态初始化
        int[][] a={
                {1,2,3},
                {4,5,6,7},
                {8,9,10}
        };


        System.out.println(a[2][2]);
        System.out.println("--------------------");
        printArray(a);
        System.out.println("--------------------");
        printArray(new int[][] { {11,22},{33,44,55} });

    }
    public static void printArray(int[][] array){
        for(int i=0;i<array.length;i++){    //负责纵向
            for(int j=0;j<array[i].length;j++){
                System.out.print(array[i][j]+"  ");
            }
            System.out.println();
        }
    }
}

JavaSE进阶数组 - 文章图片

算法

冒泡排序算法

每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡）
左边和右边比大小，左边>右边时交换位置

/*
冒泡排序法：
原始数据：3 2 8 7 1  最外层循环4次 内层循环最大4次递减
第一次循环：
2 3 8 7 1(3比2,交换)
2 3 8 7 1(3比8,不交换)
2 3 7 8 1(8比7,交换)
2 3 7 1 8(8比1,交换)

第二次循环：2 3 7 1
2 3 7 1(2比3,不交换)
2 3 7 1(3比7,不交换)
2 3 1 7(7比1,交换)

第三次循环：2 3 1
2 3 1(2比3,不交换)
2 1 3(3比1,交换)

第四次循环：2 1
1 2(2比1,交换)

*/

public class BubbleSort {
    public static void main(String[] args) {

        int[] a={3 ,2 ,8 ,7 ,1};
        //5个数据,循环4次
        //for(int i=0;i<a.length-1;i++){}

        //定义一个比较次数
        int count=0;
        //采用递减的方式与内层循环有联系
        for(int i=a.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                count++;
                if(a[j]>a[j+1]){
                    int temp;
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        //比较次数
        System.out.println("比较次数："+count);
        //输出结果
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

选择排序算法

每一次从这堆参与比较的数据当中找出最小值，拿着这个最小值和最前面的元素交换位置，选择排序比冒泡排序好在：每一次交换位置都是有意义的。关键点在于找出最小，先假设一开始最左边最小，假设

第一个3最小，3和2比，发现2更小，所以此时最小的是2
继续拿着2往下比对，2和6比较，2仍然是最小的
继续拿着2往下比对，2和1比较，发现1更小，所以此时最小的是1
继续拿着1往下比对，1和5比较，1仍然是最小

与冒泡排序算法相比：比较次数一样、交换次数减少

/*

第一次循环：参与 3 1 6 2 5 （参与比较的最左边的元素下标为0）
1 3 6 2 5（排序后）
第二次循环：参与 3 6 2 5（参与比较的最左边的元素下标为1）
2 6 3 5（排序后）
第三次循环： 参与 3 6 5（参与比较的最左边的元素下标为2）
3 6 5（排序后）
第四次循环：参与 6 5（参与比较的最左边的元素下标为3）
5 6（排序后）

5条数据，循环4次
*/
public class SelectSort {
    public static void main(String[] args) {

        int[] a={3,1,6,2,5};
        int count=0;
        for(int i=0;i<a.length-1;i++){
            //这时输出i正好是0 1 2 3 对应着起点下标
            //假设起点i下标位置上的元素是最小的
            int min=i;
            for(int j=i+1;j<a.length;j++){
                count++;
                //输出j 对应i=0时 j为1 2 3 4
                if(a[j]<a[min]){
                    min=j;
                }
            }
            //当i和min相等,说明一开始的假设是对的
            //如果不相等，说明有更小的元素,需要交换位置
            if(min!=i){
                int temp;
                temp=a[min];
                a[min]=a[i];
                a[i]=temp;
            }

        }
        //比较次数
        System.out.println("比较次数："+count);
        //排序之后遍历
        for(int k=0;k<a.length;k++){
            System.out.println(a[k]);
        }
    }
}

二分法查找

JavaSE进阶数组 - 文章图片

线性查找

//需求：找出89的下标，如果没有，返回-1
public class ArraySearch {
    public static void main(String[] args) {
        int[] a = {1, 6, 89, 55, 34};
        int index = arraySearch(a, 55);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标是" + index);
    }

    //参数1：传入的数组  参数2：要找的元素值
    //返回值返回下标，没有返回-1
    public static int arraySearch(int[] array,int x){
        for(int i=0;i<array.length;i++){
            if(x==array[i]){
                return i;
            }
        }
        return -1;
    }
}

二分法查找（基于排序的基础上）

public class ArrayUtil {
    public static void main(String[] args) {
        int[] a = {1, 6, 11, 13, 17,19};
        int index = binarySearch(a, 11);
        System.out.println(index == -1 ? "该元素不存在" : "该元素下标是" + index);
    }

    //参数1：传入的数组  参数2：目标元素
    //返回值返回下标，没有返回-1
    public static int binarySearch(int[] array,int dest){

        //开始下标
        int begin=0;
        //结束下标
        int end=array.length-1;


        //开始元素的下标只要在结束元素下标的左边,就有机会循环
        while (begin<=end){
            //中间元素下标
            int mid=(begin+end)/2;

            if (array[mid] == dest) {
                return mid;
            } else if (array[mid] < dest) {
                //到这里说明目标在中间的右边
                begin = mid + 1;
            } else {
                //目标在中间的左边
                end = mid - 1;
            }
        }
        return -1;
    }
}

数组工具类

java.util.Arrays 工具类中的方法大多都是静态的，其中有sort( )方法和binarySort( )，可以排序。静态方法，直接使用类名调用就行。

public class ArraysTest08 {
    public static void main(String[] args) {

        int[] a={11,34,5,43,33,44};
        //排序
        Arrays.sort(a);
        //遍历
        for(int i=0;i<a.length;i++){
            System.out.print(a[i]+"   ");
        }

        System.out.println();

        //二分法查找
        int index=Arrays.binarySearch(a,44);
        System.out.println(index==1?"该元素不存在":"该元素的下标是"+index);

    }
}

JavaSE进阶数组 - 文章图片

内容总结

以上是互联网集市为您收集整理的JavaSE进阶数组全部内容，希望文章能够帮你解决JavaSE进阶数组所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/589211.html

来源：【匿名】

【上一篇】Java——面向对象【下一篇】JAVA/JSP学习系列之五

更多 ►

【JavaSE进阶数组】教程文章相关的互联网学习教程文章

集合（一）-Java中Arrays.sort()自定义数组的升序和降序排序【代码】

默认升序package peng;import java.util.Arrays; public class Testexample {public static void main(String[] args) { int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a);for(int arr:a) {System.out.print(arr + " ");}}}自定义　利用Collections.reverseOrder()方法：package peng;import java.util.Arrays; import java.util.Collections; public class Testexample {public static void ma...

剑指Offer面试题8（java版）:旋转数组的最小数字【图】

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为旋转。输入一个递增的排序的数组的一个旋转，输出旋转数组的最小元素。例如数组｛3，4，5，1，2｝为{1,2,3,4,5}的一个旋转，该数组的最小元素为1.这道题最直观的解法并不难，从头到尾遍历一次，我们就能找到最小的元素。这种思路的时间复杂度为O（n)。但是这个思路没有利用输入的旋转数组的特性，肯定达不到面试官的要求。我们注意到旋转之后的数组实际上可以划分...

Java源代码分析之Vector数组【代码】【图】

Vector源码分析每个Java程序员应该的特性可变长数组（grow or shrink）能够使用索引获取值（accessed using an integer index）多线程环境下线程安全类图package java.util;import java.util.function.Consumer; import java.util.function.Predicate; import java.util.function.UnaryOperator;/* vector 通过capacity（容量）和capacityIncrement（增量）两个属性来最化管理存储， capacity 一般都比 size 大。当知道需要插入大...

java第五天之---方法与数组【图】

案例一：从键盘输入两个数据，比较大小import java.util.Scanner;class FunctionTest { 　　public static void main(String[] args) { 　　　　Scanner sc = new Scanner(System.in); 　　　　System.out.println("input a number:"); 　　　　int a = sc.nextInt(); 　　　　System.out.println("input another nuber:"); 　　　　int b = sc.nextInt(); 　　　　int result = Get...

Java05：数组【代码】【图】

五、Java数组（一）什么是数组类比：一支球队就是一个数组，里面每一个人都是一个数组元素。（二）数组的声明和创建声明数组变量dataType[] arratRefVar; //常用，java样式 dataType arratRefVar[];//少用,C样式 new操作符创建数组dataType[] arratRefVar = new dataType[arraySize];arratRefVar[0]= 变量的值;//赋值操作（三）三种初始化以及内存分析三种初始化静态初始化int[] a= {1,2,3}; Man[] mans = {new Man(1,1),new Ma...

java数据结构-栈的底层实现：数组实现压入，弹出，判断空栈测试代码【代码】

package com.stack;/** * @auther 付强 * @date 2020/2/13 - 13:08 */public class TestMystack { public static void main(String[] args) { //先创建一个栈 Mystack mystack = new Mystack(); //压入数据 mystack.push(9); mystack.push(8); mystack.push(7); mystack.push(6); mystack.push(5); System.out.println(mystack.pick()); System.out.pri...

javaScript之数组（二）【代码】

***数组API： *栈和队伍：其实都是数组，只不过使用了不同的方法栈：一端封闭，只能从另一端进出的*数组* 何时使用栈：只能从数组一端进出结尾出入栈：入栈：arr.push(新值)； ==>arr.[arr.length]=新值；出栈：var last=arr.pop();案例：var bus=[];for(var i=0;i<5;i++){ bus.push("乘客"+i); alert(bus);}while(bus.length>0){ var cust=bus.pop(); alert(cust+...

Javascript基础知识盲点总结——数据类型和数组

一、javascript总的基本类型1.javascript中的基本类型共有五种：数字、字符串、布尔值、undefined、null其中null和undefined最大的区别在于，被赋予null的变量通常被认为是已经定义了的。2.除了以上五种基本类型外，其他的数据类型都属于对象。二、利用typeof方法查看数据类型在javascript中可以通过typeof方法来查看某个变量或值得数据类型。该方法会返回一个代表数据类型的字符串，可能返回的值包括：number,string, boolean, un...

javascript 笔试题之删除数组重复元素【代码】

笔试时紧张没写出来,静下心后发现简单的要死.<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html lang="en"><head><meta http-equiv="Content-Type" content="text/html;charset=UTF-8"><title>删除数组重复元素</title></head><body><script>/*** 删除数组重复元素* @param array 目标数组* @return 返回去重后的数组*/function array_unique(arr) {//外层循环控制次...

剑指Offer面试题29（java版）：数组中出现次数超过一半的数字

题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。比如输入一个长度为9的数组｛1，2，3，2。2，2。5，4，2｝。因为数字2在数组中出现5次，超过数组长度的一半，因此输出2.解法一：基于Partition函数的O(n)算法：我们的算法是受高速排序的算法的启示。在随机高速排序的算法中。我们先在数组中随机的选择一个数字。然后调数组中数字的顺序，使得比选中的数字小数字排在它的左边。比选中的数字大的数字都排在它的...

Java数组赋值效率比较问题【代码】

1.for 循环逐一复制2.System.arraycopy3.Array.copyOf4.使用clone方法以上四种方法效率比较：　　System.arraycopy > clone > System.copyOf > for循环注解：arraycopy作为natvie（本地）方法，是最快的，下面该方法源码的描述。public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length); Arrays.copyOf(Arrays类)的实现，在源码中是调用System.copyOf的，多了一个步骤。关于clone的源码...

Java 从后向前依次比较两个数组【代码】【图】

这是华为往年的一道上机题题目：给定两个数组，以及两个数组的长度，要求从最后一个元素开始，依次比较两个数组对应的元素。如果有一个数组较短，则以短数组为准。返回不同元素的个数。解答：int func(int[] array1, int len1, int[] array2, int len2){int count = 0;for(int i=len1-1, j=len2-1; i>=0&j>=0; i--,j--){if(array1[i]!=array2[j])count++;}return count;}虽然题目不难，但是这段代码是如此的简短。我没有先自己做下...

JavaOO 数组

本章目标：掌握数组的声明、初始化与使用方法掌握一维、多维数组的用法理解数组的复制掌握JavaDoc注释的使用数组概述：数组是存储在一个连续的内存块中的元素集合。数组中每个元素必须是相同的数据类型，并且通过索引进行区分。数组中的第一个元素的索引为0.数组的特点：1、长度不可变2、只能存放同一数据类型3、连续内存地址为什么要使用数组：创建数组：1、声明数组变量语法：数据类型[] 数组变量名；数据类型数组变量名[]；2、使...

java实现无序数组结构【代码】

一、数组的2种定义方式数据类型 [] 数组名称 = new 数据类型[数组长度];这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，一般放在名称的前面数据类型 [] 数组名称 = {数组元素1，数组元素2，......}这种方式声明数组的同时直接给定了数组的元素，数组的大小有给定的数组元素个数决定publicclass ArrayStruct {publicstaticvoid main(String[] args) { // int[] nums = new int[10]; // int nums[] = ne...

JavaScript基础---一维数组转二维数组

var arr1=[1,2,3,4,5,6,7,8,9]// 方法一，用数组截取的方法 function fn(arr,n){arr=[].concat(arr)var newArr=[]while(arr.length){newArr.push(arr.splice(0,n))}return newArr}console.log(fn(arr1,2)) （注意不要改变原数组） //方法二 function fn1 (arr,n) { var newArr=[] for(var i=0;i<arr.length;i++){ //确定页数 var page=Math.floor(i/n) if(!newArr[page]){ newArr[pag...

首页 / JAVA / JavaSE进阶 数组

JavaSE进阶 数组

内容导读

内容图文

一维数组

概述

内存结构图

优点

缺点

声明/定义

初始化

遍历数组

方法参数是数组

解析mian方法参数

存储引用数据类型

数组扩容

二维数组

遍历

算法

冒泡排序算法

选择排序算法

二分法查找

数组工具类

内容总结

内容备注

内容手机端

【JavaSE进阶 数组】教程文章相关的互联网学习教程文章

JAVASE - 相关标签

数组 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

首页 / JAVA / JavaSE进阶数组

JavaSE进阶数组

【JavaSE进阶数组】教程文章相关的互联网学习教程文章