纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

Java数组 Java开发必备知识之数组详解

北夷烟雪江中雨   2021-06-01 我要评论
想了解Java开发必备知识之数组详解的相关内容吗,北夷烟雪江中雨在本文为您仔细讲解Java数组的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java二维数组,java数组,下面大家一起来学习吧。

一、ASCII码

在这里插入图片描述

二、为什么需要数组

案例: 160班 现在 77人   统计 全班的Java成绩  用程序进行存储  变量   统计  全班不及格的同学  
要 补考  补考过的同学 修改成绩  
定义  77 个变量  
 int 帅  =  59;
 int  洋 = 100;
 int  cto   = 60;
 int  ceo = 58;

三、什么是数组

概念:数组就是内存中一块 连续的 内存空间,用于存放 相同类型 的多个数据

四、定义数组

声明一个数组:确定数组中存放的数据类型
	语法:
		数据类型[]  数组名;//建议
		数据类型  []数组名;
        数据类型  数组名[];//c语言的写法  不建议 
    案例:
     //声明一个数组
        int[] a ;
为数组开辟空间:确定了数组的容量大小
	语法:数组名 = new 数据类型[数组的长度];
	案例://为数组开辟空间
        a = new int[77];

数组的长度:自动获取数组的长度  数组名.length
数组的下标:为每个数组的元素分配一个标号  0------数组名.length-1
数组的元素:数组中每个小空间叫做数组的一个元素相当于一个变量

定义数组的其他方式
	第一种:声明 开辟空间(隐式)
		1)先声明 后开辟空间
		语法: 
		数据类型[]  数组名;//声明
		数据名 = new 数据类型[数组长度];//开辟空间
		2)声明的同时并开辟空间
		语法:数据类型[] 数组名 = new 数据类型[数组长度];
	第二种:声明 赋值(显式初始化)
		1)先声明  后赋值
		语法:
		数据类型[] 数组名 ;//声明
		数组名 = new 数据类型[]{元素1,元素2,元素3,。。。};//赋值
		2)声明的同时并赋值
		语法:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,。。。};
			简写形式:数据类型[] 数组名 = {元素1,元素2,元素3,。。。};
			注意:
			1.简写形式不能分为两行 数组的声明和赋值必须在同一行
			2.在定义数组的过程中 不能既赋值同时又定义长度

五、使用数组

存数据:为每个元素赋值
取数据:
	语法:数组名[数组下标] = 值;
	案例:
	public class Demo{
    public static void main(String[] args) {
        //声明一个数组
        int[] a ;
        //为数组开辟空间
        a = new int[4];
        //存数据
        a[0] = 2;
        a[1] = 4;
        a[2] = 6;
        a[3] = 8;

        //访问数据
        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
        System.out.println(a[3]);
        //获取数组的长度
        System.out.println("数组的长度:"+a.length); 
    }
    
}

六、数组的默认值

当定义一个数组没有为数组赋值数组的每一个元素都有一个默认值 默认值的类型和数组的类型是相关的

简单数据类型
byte--------------0
short-------------0
int  -------------0
long--------------0

float ------------0.0
double------------0.0

char-------------空字符  '\u0000'

boolean----------false

引用数据类型(对象类型)------null

案例:
public class Demo{
    public static void main(String[] args) {
        //定义一个数组
        String[] a = new String[5];

        System.out.println(a[0]);
        System.out.println(a[1]);
        System.out.println(a[2]);
        System.out.println(a[3]);
        System.out.println(a[4]);
        
    }
    
}

七、数组的遍历

遍历:访问数组中的每个元素并打印

案例:
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,5,6,7,8,3,23,56,78,52,34};

        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+"\t");          
        }
        
    }
    
}

八、数组在内存中的分析

int[] a = new int[4];
a的引用指向  数组在堆内存中的实体  (见图示)

元素的地址值 = 首地址+数据类型字节数*下标

案例:
public class Demo{
    public static void main(String[] args) {
        int[] a = new int[3];
        a[0] = 2;
        a[1] = 3;
        a[2] = 5;

        int[] b = new int[4];

        b = a;
        System.out.println("b数组的长度:"+b.length);
        System.out.println("a数组的长度:"+a.length);
        for(int i =0;i<b.length;i++){
            System.out.print(b[i]+" ");
                       
        }
    }
    
}

九、数组的扩容

思想:
1.定义一个新的数组 容量要比之前的数组大
2.将原数组中的元素 复制到新数组中
3.将原数组的引用指向新数组

注意:如果超出了数组的下标 那么会报异常
java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
方法:
=========================================================================================
第一种:自己写
代码:
public class Demo{
    public static void main(String[] args) {
        int[] a = {2,4,6,3,7,5,23};//7
        System.out.println("扩容之前的长度:"+a.length);
        
        //1,定义一个新数组
        int[] b = new int[a.length*2];
        //2,将原数组元素复制到新数组中
        for(int i = 0;i<a.length;i++){
            b[i] = a[i];          
        }
        
        //3 将a的引用指向新数组
        a = b;

        //遍历a数组
        System.out.println("扩容之后的长度:"+a.length);
        
        for(int i = 0;i<a.length;i++){
           System.out.print(a[i]+" ");     
        }
    }
    
}
=================================================================
第二种:利用 System.arraycopy(原数组名,原数组的起始下标,新数组名,新数组的起始下标,要复制的长度)
代码:
public class Demo{
    public static void main(String[] args) {
        int[] a = {2,4,6,3,7,5,23};//7
        System.out.println("扩容之前的长度:"+a.length);
        
        //1,定义一个新数组
        int[] b = new int[a.length*2];
        //2,将原数组元素复制到新数组中
        System.arraycopy(a,0,b,0,a.length);
        /*for(int i = 0;i<a.length;i++){
            b[i] = a[i];          
        }
        */
        //3 将a的引用指向新数组
        a = b;

        //遍历a数组
        System.out.println("扩容之后的长度:"+a.length);
        
        for(int i = 0;i<a.length;i++){
           System.out.print(a[i]+" ");     
        }
    }
    
}
==================================================================
第三种:利用Arrays工具类 操作
Arrays是java.util包中的一个工具类
Arrays.copyOf(原数组,扩容之后的长度) 此函数可以返回一个新的扩容之后的数组数组长度由函数的第二个参数决定
代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {2,4,6,3,7,5,23};//7
        System.out.println("扩容之前的长度:"+a.length);

        a = Arrays.copyOf(a,a.length*2);

        System.out.println("扩容之后的长度:"+a.length);
        //遍历
        for(int i = 0;i<a.length;i++){
           System.out.print(a[i]+" ");     
        }
    }
    
}

练习:随机点名系统
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        String[] s = {"",""};
        //系统随机产生一个下标
        int index = (int)(Math.random()*s.length);
        System.out.println(s[index]);
        
       
    }
    
}

案例:随机赋值
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = new int[10];

        //循环赋值
        for(int i = 0;i<a.length;i++){
            a[i] = (int)(Math.random()*100);          
        }
        //遍历
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+"  ");
                      
        } 
    }    
}

十、数组用在函数的参数上

案例:写一个函数 函数的功能是遍历数组  形参类型 数组类型  参数几个 1  返回值 void    printArray
代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,4,56,7,8,8,9,9,3,5,66,77,88};
        printArray(a);
        System.out.println();
        
        int[] b = new int[10];
        printArray(b);
    }
    //
    public static void printArray(int[] a) {

        for(int i = 0;i<a.length;i++){
           System.out.print(a[i]+",");
                 
        }
    }
    
    
    
}

数组用在函数的参数和返回值上

案例:写一个函数 实现数组的扩容   
代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,4,56,7,8,8,9,9,3,5,66,77,88};
        //调用 扩容
        a = myCopyOf(a);
        printArray(a);
       
        
    }
    //
    public static void printArray(int[] a) {

        for(int i = 0;i<a.length;i++){
           System.out.print(a[i]+",");
                 
        }
    }

    //扩容数组
    public  static int[] myCopyOf(int[] a) {
        //定义一个新数组
        int[] b = new int[a.length*2];
        //将原数组的元素复制到新数组
        for(int i = 0;i<a.length;i++){
            b[i] = a[i];           
        }
        return b;
    }   
}

案例:定义一个函数  函数的功能是 计算多个数的和  数不定 
代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,4,5};
        int sum = add(a);
        System.out.println(sum);
        
        
    }
 
    //定义一个函数 实现 计算几个数的和
    public static int add(int[] a) {
        int sum = 0;
        for(int i = 0;i<a.length;i++){
            sum+=a[i];            
        }
        return sum;
    }
}

十一、函数可变长参数

语法: 数据类型... 变量名 
就相当于 数据类型[]  变量名;

public static 返回值类型  函数名(数据类型... 变量名){

}
注意:可变长参数函数中的形参列表只能有一个可变长参数,如果有其他的形参,那么可变长参数必须放在参数列表的最后
案例:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        /*int sum1 = add(3,4,5);
        int sum2 = add(4,6,9);
        int sum3 = add(3,6,8,9,4,3);*/
        int sum = add(3,4,6);
        System.out.println(sum);
        
        
    }
    //定义一个可变长参数函数
    public static int add(int b,int c,int...a) {
        int sum = 0;
        for(int i = 0;i<a.length;i++){
            sum+=a[i];           
        }
        return sum;
    }
    
    
}


案例:传数组也可以  
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {1,2,3};
        int sum = add(a);
        
        System.out.println(sum);
        
    }
    //定义一个可变长参数函数
    public static int add(int...a) {
        int sum = 0;
        for(int i = 0;i<a.length;i++){
            sum+=a[i];           
        }
        return sum;
    }
    
    
}

案例:这样是不行的
import java.util.*;
public class Demo{
    public static void main(String[] args) {
       int sum = add(2,4,5);
        
        System.out.println(sum);
        
    }
    //定义一个可变长参数函数
    public static int add(int[] a) {
        int sum = 0;
        for(int i = 0;i<a.length;i++){
            sum+=a[i];           
        }
        return sum;
    }
}

十二、数组的排序

 1.4. 6.8.3 ----  1 3 4 6 8
 
 套路:算法

十三、冒泡排序

规则:相邻的两个元素进行比较 如果前者大于后者 则两者交换位置

案例: 3,1,4,2  ------->1 2 3 4


***
**
*

双重for循环


代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,5,87,34,67,2,95,36,67,78};              
        //int[] a = {3,1,4,2};
        //冒泡排序
        for(int i = 1;i<=a.length-1;i++){
            for(int j = 0;j<a.length-i;j++){
                if (a[j]>a[j+1]) {
                    //交换位置
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                } 
                         
            }           
        }
        //遍历
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+" ");
                      
        }
                
    } 
 
}

在这里插入图片描述

选择排序

规则:在数组中选择一个数 和其他的数进行比较 如果这个数大于其他的数 那么两者交换位置

代码:
import java.util.*;
public class Demo{
    public static void main(String[] args) {
        int[] a = {3,5,87,34,67,2,95,36,67,78};              
        //int[] a = {3,1,4,2};
        //冒泡排序
        /*for(int i = 1;i<=a.length-1;i++){
            for(int j = 0;j<a.length-i;j++){
                if (a[j]<a[j+1]) {
                    //交换位置
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                } 
                         
            }           
        }*/


        //选择排序
        for(int i = 0;i<=a.length-2;i++){
            for(int j = i+1;j<a.length;j++){
                if (a[i]>a[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                } 
                          
            }          
        }
        //遍历
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+" ");         
        }        
    } 
}

在这里插入图片描述

快速排序

 jdk提供的属于java.util中的Arrays工具类的函数
 java.util.Arrays.sort(a);

代码:

public class Demo{
    public static void main(String[] args) {
        int[] a = {3,5,87,34,67,2,95,36,67,78};              
        //int[] a = {3,1,4,2};
        //快速排序
        java.util.Arrays.sort(a);
        //遍历
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+" ");         
        }        
    } 
 
}

十四、二维数组

概念:是一维数组的一维数组
数组:
	8中基本数据类型
	引用数据类型  数组是引用数据类型 
数据类型[] -----数组类型 

二维数组的定义

数组的声明:
语法:
数据类型[][] 数组名;

为数组分配空间
语法:
数组名 = new 数据类型[高维数组长度][低维数组长度]
案例:

public class Demo{
    public static void main(String[] args) {
        int[][] a = new int[4][3];
        /*int[] b = new int[4];
        b[0] = new int[3];
        b[1] = new int[3];
        b[2] = new int[3];
        b[3] = new int[3];*/
        a[0][0] = 1;
        a[0][1] = 2;
        a[1][2] = 5;
		
        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
        }
        
    } 
 
}

二维数组的遍历

方法:先遍历高维 再遍历低维

代码:
 for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
 }

二维数组的定义的其他方式

第一种:声明 分配空间
	1)先声明 后分配空间
	int[][] a;
	a = new int[4][5]  //4行5列
	2)声明并分配空间
	int[][] a = new int[4][5];
第二种:声明 赋值
	1)先声明 后赋值
	int[][] a ;
	a = new int[][]{{2,3,4},{4,5,6},{4,6,8},{3,5,7}}
	2)先声明并赋值
	int[][] a =new int[][]{{2,3,4},{4,5,6},{4,6,8},{3,5,7}}
	简写:int[][] a = {{2,3,4},{4,5,6},{4,6,8},{3,5,7}};
	注意:简写形式不能分为两行 声明和赋值必须在同一行
案例:

public class Demo{
    public static void main(String[] args) {
       //声明并赋值
       int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9},{10,11,12}};

        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
        }
        
    } 
 
}

不规则的二维数组

数组中每个元素数组的长度是不同的
int[][] a = {{1,2,3,3},{4,5},{7,8,9,8,56},{10,11,12}};
遍历:

public class Demo{
    public static void main(String[] args) {
       //声明并赋值
       int[][] a = {{1,2,3,3},{4,5},{7,8,9,8,56},{10,11,12}};

        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
        }
        
    } 
 
}

注意的问题:
1.当定义一个二维数组 可以先为高维数组进行分配空间,再一一为低维数组进行初始化
案例:

public class Demo{
    public static void main(String[] args) {
       //声明并赋值
        int[][] a;
        a = new int[3][];
        
        a[0] = new int[3];
        a[1] = new int[4];
        a[2] = new int[5];

        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
        }        
    } 
 
}

2.当定义一个二维数组,必须先为高维分配空间,因为低维数组是依赖于高维数组创建的
案例:

public class Demo{
    public static void main(String[] args) {
       //声明并赋值
        int[][] a;
        a = new int[][4];//错误的
        
        for(int i = 0;i<a.length;i++){
            for(int j = 0;j<a[i].length;j++){
                System.out.print(a[i][j]+" ");            
            }  
            System.out.println();
                    
        }        
    } 
 
}

十五、引用之间的传递

在这里插入图片描述


相关文章

猜您喜欢

  • Java文件被执行的历程 浅谈Java文件被执行的历程

    想了解浅谈Java文件被执行的历程的相关内容吗,糖拌西红柿在本文为您仔细讲解Java文件被执行的历程的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java,执行过程,下面大家一起来学习吧。..
  • redis配置缓存 Django使用redis配置缓存的方法

    想了解Django使用redis配置缓存的方法的相关内容吗,Silent丿丶黑羽在本文为您仔细讲解redis配置缓存的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:redis配置缓存,Django,redis缓存,下面大家一起来学习吧。..

网友评论

Copyright 2020 www.1downLoad.net 【第一下载站】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式