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 
 

八、数组在内存中的分析

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 
 

九、数组的扩容

思想：
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 
 

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

案例：写一个函数 函数的功能是遍历数组  形参类型 数组类型  参数几个 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 
 

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

案例：写一个函数 实现数组的扩容   
代码：
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 
 

案例：定义一个函数  函数的功能是 计算多个数的和  数不定 
代码：
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 
 

十一、函数可变长参数

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

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 
 

十二、数组的排序

 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;ja[j+1]) {
                    //交换位置
                    int t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                } 
                         
            }           
        }
        //遍历
        for(int i = 0;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;ja[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                } 
                          
            }          
        }
        //遍历
        for(int i = 0;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 
 

十四、二维数组

概念：是一维数组的一维数组
数组：
	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 
 

二维数组的遍历

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

代码：
 for(int i = 0;i 
 

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

第一种：声明 分配空间
	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 
 

不规则的二维数组

数组中每个元素数组的长度是不同的
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 
 

注意的问题：
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 
 

十五、引用之间的传递

到此这篇关于Java开发必备知识之数组详解的文章就介绍到这了,更多相关Java数组内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！