Java学习路线-3：数组

最新推荐文章于 2022-09-05 23:53:04 发布
最新推荐文章于 2022-09-05 23:53:04 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： java Java学习路线
本文为博主原创文章，欢迎转载，请注明出处
本文链接：https://blog.csdn.net/mouday/article/details/102761404
版权

七、数组的定义与使用

25 数组的基本定义

数组：一组相关变量的集合
引用数据类型

数组定义
1、数组动态初始化(默认值是对应类型的默认值)
数据类型 数组名称 [] = new 数据类型[长度];
数据类型[] 数组名称 = new 数据类型[长度];

2、数组静态初始化
简写：
数据类型 数组名称 [] = {数据1， 数据2， 数据3…};

完整格式（推荐）：
数据类型 数组名称 [] = new 数据类型[] {数据1， 数据2， 数据3…};

下标访问元素，下标从0开始
下标范围：0 ~ 长度-1


// 1、动态初始化
int data[] = new int[3];

// 设置值
data[0] = 1;
data[1] = 2;
data[2] = 3;

//遍历，获取值
for (int i = 0; i < data.length ; i++) {
    System.out.println(data[i]);
    // 1 2 3
}


// 2、静态初始化
int[] data = new int[]{1, 2, 3};

//遍历，获取值
for (int i = 0; i < data.length ; i++) {
    System.out.println(data[i]);
    // 1 2 3
}

26 数组引用传递分析

数组是引用数据类型

int[] data = new int[]{1, 2, 3};
int[] temp = data;
temp[0] = 10;

//遍历，获取值
for (int i = 0; i < data.length ; i++) {
    System.out.println(data[i]);
    // 10 2 3
}

27 foreach输出

JDK>=1.5 避免操作下标，从.NET引入
语法

foreach(数据类型 变量: 数组|集合){}

int[] data = new int[]{1, 2, 3};
         
for (int temp : data) {
    System.out.println(temp);
    // 1 2 3
}

28 二维数组

定义
1、动态初始化

数据类型[][] 数组名称 = new 数据类型[行个数][列个数] ;

2、静态初始化

数据类型[][] 数组名称 = new 数据类型[][] {{数据1, 数据2, ...}, {数据1, 数据2, ...}...} ;

int[][] data = new int[][]{{1, 2, 3}, {4, 5, 6}};

// for循环
for (int x = 0 ; x < data.length ; x ++) {
    for (int y = 0 ; y < data[x].length ; y ++) {
        System.out.println(data[x][y]) ;
         // 1 2 3 4 5 6 
    }
}

// foreach 循环
for (int[] row : data) {
    for (int cell : row) {
        System.out.println(cell) ;
        // 1 2 3 4 5 6 
    }
}

29 数组与方法

同一块堆内存被不同栈变量指向

class ArrayDemo{
    public static int[] getArray(){
        int[] arr = new int[] {1, 2, 3};
        return arr;
    }

    public static void printArray(int[] arr){
        for(int x : arr) {
            System.out.println(x);
        }
    }

    public static void main(String[] args) {
       int[] arr = getArray();
       printArray(arr); 
       // 1 2 3 
    }
}

主类：主方法所在的类
主类的功能不能过于复杂

// 封装起来的数组工具类
class ArrayUtil{
    
    public static int getSum(int[] arr){
        int sum = 0 ;

        for(int x : arr){
            sum += x ;
        }
        return sum ;
    }

    public static double getAvg(int[] arr){
        return getSum(arr) / arr.length;
    }

    public static int getMax(int[] arr){
        
        // 假设最大值为第一个元素
        int max = arr[0];

        for(int x : arr){
            if(x > max){
                max = x;
            }
        }
        return max;
    }

    public static int getMin(int[] arr){
        
        // 假设最小值为第一个元素
        int min = arr[0];

        for(int x : arr){
            if(x < min){
                min = x;
            }
        }
        return min;
    }
    
    public static void main(String[] args) {
        int[] arr = new int[] {1, 2, 3, 4, 5};
        System.out.println("sum: " + ArrayUtil.getSum(arr));
        System.out.println("avg: " + ArrayUtil.getAvg(arr));
        System.out.println("max: " + ArrayUtil.getMax(arr));
        System.out.println("min: " + ArrayUtil.getMin(arr));
        /**
        sum: 15
        avg: 3.0
        max: 5
        min: 1
        */
    }
}

30 数组排序案例分析

类中没有数据，可以使用static 静态方法，直接使用类名调用

// 封装起来的数组工具类
class ArrayUtil{

    public static void sort(int[] arr){
        // 第一层 控制比较次数 length - 1
        for(int y = 0; y < arr.length - 1; y++){
            // 第二层 无序区做比较即可 length - n - 1
            for(int x = 0 ; x < arr.length - y - 1; x++){
                if(arr[x] > arr[x+1]){
                    int temp = arr[x];
                    arr[x] = arr[x + 1];
                    arr[x+1] = temp;
                }
            }
        }
    }

    public static void printArray(int[] arr){
        System.out.print("[ ");

        for(int x : arr){
            System.out.print(x);
            System.out.print(" ");
        }

        System.out.println("]");
    }

    public static void main(String[] args) {
        int[] arr = new int[] {4, 5, 1, 3, 2};
        ArrayUtil.sort(arr) ;
        ArrayUtil.printArray(arr);
        // [ 1 2 3 4 5 ]
    }
}

31 数组转置案例分析

方式一：
使用临时数组，增加了垃圾

public static int[] reverse(int[] arr){
    int[] temp = new int[arr.length] ;
    int foot = arr.length - 1 ;

    for(int i = 0; i < arr.length ; i++){
        temp[foot--] = arr[i];
    }
    return temp;
}

public static void main(String[] args) {
    int[] arr = new int[] {1, 2, 3, 4, 5};
    arr = ArrayUtil.reverse(arr) ;
    ArrayUtil.printArray(arr);
    // [ 5 4 3 2 1 ]
}

java中整数相除，向下取整

System.out.println(5/3); // 1
System.out.println(5.0/3); // 1.66

方式二：
使用数组自身交换，使用if，增加了时间复杂度

public static void reverse(int[] arr){
    int center = arr.length / 2;

    int head = 0;
    int tail = arr.length - 1;

    for(int i = 0; i < center ; i++){
        int temp = arr[head];
        arr[head] = arr[tail];
        arr[tail] = temp;
        head ++;
        tail --;
    }
}

public static void main(String[] args) {
    int[] arr = new int[] {1, 2, 3, 4, 5};
    ArrayUtil.reverse(arr) ;
    ArrayUtil.printArray(arr);
    // [ 5 4 3 2 1 ]
}

32 数组相关类库

1、数组排序
java.util.Arrays.sort(数组)

int[] arr = new int[] {5, 4, 2, 3, 1};
java.util.Arrays.sort(arr);
ArrayUtil.printArray(arr);
// [ 1 2 3 4 5 ]

2、数组拷贝
System.arraycopy(源数组, 源数组开始点, 目标数组, 目标数组开始点, 拷贝长度)

int[] arr1 = new int[] {1, 2, 3, 4, 5};
int[] arr2 = new int[] {11, 22, 33, 44, 55};
System.arraycopy(arr1, 1, arr2, 1, 3) ;

ArrayUtil.printArray(arr2);
// [ 11 2 3 4 55 ]

自定义方法实现

public static void arraycopy(int[] source, int sourceIndex, int[] target, int targetIndex, int length){
        for(int i = 0 ; i < length; i++){
            target[targetIndex + i] = source[sourceIndex + i];
        }
    }

public static void main(String[] args) {
    int[] arr1 = new int[] {1, 2, 3, 4, 5};
    int[] arr2 = new int[] {11, 22, 33, 44, 55};
    ArrayUtil.arraycopy(arr1, 1, arr2, 1, 3) ;
    
    ArrayUtil.printArray(arr2);
    // [ 11 2 3 4 55 ]
}

33 方法可变参数

JDK >= 1.5

// 接收可变参数
public static int getSum(int ... arr){
    int sum = 0 ;

    for(int x : arr){
        sum += x ;
    }
    return sum ;
}

public static void main(String[] args) {
    
    int sum1 = ArrayUtil.getSum(1, 2, 3, 4, 5);
    int sum2 =  ArrayUtil.getSum(new int[] {1, 2, 3, 4, 5});
    
    System.out.println(sum1); // 15
    System.out.println(sum1); // 15 
}

34 对象数组


class Person{
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    public String getInfo(){
        return  "name: " + this.name + 
                " age: " + this.age ;
    }

}

动态初始化


Person[] persons = new Person[3];
persons[0] = new Person("张三", 23) ;
persons[1] = new Person("李四", 24) ;
persons[2] = new Person("王五", 25) ;

for (Person person : persons) {
    System.out.println(person.getInfo());
}
/**
name: 张三 age: 23
name: 李四 age: 24
name: 王五 age: 25
*/

静态初始化

Person[] persons = new Person[]{
    new Person("张三", 23), 
    new Person("李四", 24),
    new Person("王五", 25) 
};


for (Person person : persons) {
    System.out.println(person.getInfo());
}
/**
name: 张三 age: 23
name: 李四 age: 24
name: 王五 age: 25
*/

数组特征：
1、数组缺点：长度固定
2、数组优势：线性保存，根据索引取值，速度较快，时间复杂度为1

八、引用传递实际应用

35 类关联结构


class Car{
    private String name;
    private double price;
    private Person person;

    public Car(String name, double price){
        this.name = name;
        this.price = price;
    }

    // 设置、获取车主
    public void setPerson(Person person){
        this.person = person ;
    }

    public Person getPerson(){
        return this.person;
    }
    
    public String getInfo(){
        return  "name: " + this.name + 
                " price: " + this.price ;
    }
}

class Person{
    private String name;
    private int age;
    private Car car;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    public String getInfo(){
        return  "name: " + this.name + 
                " age: " + this.age ;
    }

    // 设置、获取车辆
    public void setCar(Car car){
        this.car = car ;
    }

    public Car getCar(){
        return this.car ;
    }

    public static void main(String[] args) {
        Person person = new Person("张三", 23) ;
        Car car = new Car("特斯拉", 24) ; 

        // 关联车辆和人
        person.setCar(car) ; 
        car.setPerson(person) ; 

        // 通过人获取车辆
        System.out.println( person.getCar().getInfo()) ;
        // name: 特斯拉 price: 24.0

        // 通过车辆获取人
        System.out.println( car.getPerson().getInfo()) ;
        // name: 张三 age: 23
    }
}

36 自身关联


class Car{
    private String name;
    private double price;
    private Person person;

    public Car(String name, double price){
        this.name = name;
        this.price = price;
    }

    // 设置、获取车主
    public void setPerson(Person person){
        this.person = person ;
    }

    public Person getPerson(){
        return this.person;
    }
    
    public String getInfo(){
        return  "name: " + this.name + 
                " price: " + this.price ;
    }
}

class Person{
    private String name;
    private int age;
    private Car car;
    private Person[] children ;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    // 增加孩子数组
    public Person[] getChildren(){
        return this.children;
    }

    public void setChildren(Person[] children){
        this.children = children ;
    }
    
    public String getInfo(){
        return  "name: " + this.name + 
                " age: " + this.age ;
    }

    // 设置、获取车辆
    public void setCar(Car car){
        this.car = car ;
    }

    public Car getCar(){
        return this.car ;
    }

    public static void main(String[] args) {
        Person person = new Person("张三", 23) ;

        // 添加孩子
        Person childA = new Person("小张", 19) ; 
        Person childB = new Person("小王", 19) ; 

        // 给孩子买车
        childA.setCar(new Car("法拉利", 2000000.00)) ; 
        childB.setCar(new Car("宾利", 8000000.00)) ; 

        person.setChildren(new Person[] {
            childA,
            childB
        }) ;

       System.out.println(person.getInfo()) ;
       for(Person child : person.getChildren()){
            System.out.println( "\t|" + child.getInfo()) ;
            System.out.println( "\t\t|" + child.getCar().getInfo()) ;
       }
       /**
        name: 张三 age: 23
            |name: 小张 age: 19
                |name: 法拉利 price: 2000000.0
            |name: 小王 age: 19
                |name: 宾利 price: 8000000.0
       */

    }
}

37 合成设计模式

拆分+组合

class 电脑{
    private 主机 对象;
    private 显示器 对象数组;
}

class 显示器{}

class 主机{
    private CPU 对象;
    private 键盘 对象;
    private 键盘 对象;
}

class CPU {}
class 键盘 {}
class 键盘 {}

38 综合实战：数据表与简单Java类映射转换

数据表与简单Java类之间基本映射关系
数据实体表设计 = 类的定义
表中的字段 = 类的成员属性
表的一行记录 = 类的一个实例化对象
表的多行记录 = 对象数组
表的外键关联 = 引用关联

雇员和部门关系
一个部门对应多个雇员
一个雇员对应一个部门

定义阶段：
定义实体类
配置关联字段

开发阶段：
定义对象
关联关系
根据关系获取数据

39 综合实战：一对多映射

班级对学生

40 综合实战：多对多映射

商品和顾客

41 综合实战：复杂多对多映射

用户 权限

彭世瑜
关注
专栏目录
Java学习路线总结（思维导图篇）
学Java，找哪吒
10-21 18万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java的引用数据类型——数组
哈哈哈哈的博客
05-03 2248
数组的声明与开辟1、数组动态初始化   数据类型 数组名称 [] = new 数据类型 [长度]   数据类型 [] 数组名称 = new 数据类型 [长度]引用数据类型使用之前必须开辟空间，若不开辟会出现NullPointerException数组开辟后，采用“数组名[索引]”来操作数组，索引的范围是0~数组长度-1。动态初始化的数组中所有数据内容都是数据类型的默认值，若是int类型，默认值为0...
【java】数组是基本类型还是引用类型
之虎者也的博客
12-20 6357
答：是引用类型。 这里通过一个简单的样例进行说明： public static void main(String[] args) { int[] a = {1,2}; int[] b = a; a[0] = 10; System.out.println(b[0]); //输出10 } 可以看到，把数组a的第一个值改为10后，输出b的第一个值也是10，a和b两个变量引用了同一个数组。虽然保存的是基本类型值int，但是数组本身是引用类型的。 ...
第二章：数组
qq_28384023的博客
11-13 277
asdasd
数据类型之引用数据类型篇（数组基础）
xiao_yi_8421的博客
08-02 2475
数组 数组的定义 数组（Array）是有序的元素序列，在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式，这些有序排列的同类数据元素的集合称为数组。 数组可以看做相同数据类型的数据的一个存储容器,可以对这些数据进行统一管理，在java中数组是一个源自底层的数据结构，同时也为了操作数组定义了一个java.util.Arrays类。 其实不仅仅是在java中,在任何语言中,数组都是最基本的数据结构 它是一个用于存储连续的内存空间的集合,并且每个内存空间都有一个独一无二的编号 数
java简易投票系统源码下载-study-way:学习路线
06-05
内部使用数组保存数据，不够时翻倍。 树 二叉树 每个节点最多有两个叶子节点。 完全二叉树 叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。 平衡二叉树 左右两个子树...
java-algorithms-data-structures:Java中的算法，数据结构和编码挑战实现
04-12
在Java编程语言中，理解和掌握算法与数据结构是提升编程能力的关键步骤。"java-algorithms-data-structures"项目提供了一个平台，让开发者可以实践这些核心概念，并通过编码挑战来加深理解。这个项目不仅包含了常见...
leetcode手册JAVA-JavaLearn:学习java的路线和项目实战，javalearner快来看一看吧！
06-30
应届生Java找工作基础学习路线+项目实战 视频链接： 总览图 1. 编程基础 编程基础这一块主要是编程语言以及大家本科所学习的如数据结构与算法，计算机网络，数据库，操作系统，设计模式等课程的内容，着都是很重要的...
Pacman-Java:使用Java的吃豆子游戏
04-27
《Pacman-Java: 使用Java实现的经典吃豆子游戏详解》 在计算机编程的世界里，经典的游戏总能激发程序员们的创作热情。其中，“吃豆子”（Pacman）游戏以其简单而富有挑战性的玩法，成为了许多初学者学习编程时的...
【Java基础(五)】引用数据类型-数组
haolinbird的博客
09-05 937
数组是相同类型数据的有序集合数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
（4）计算一维数组、一维数组对象指定属性的平均值 getAvg
blog
10-17 1302
求平均值，可计算一维数组，一维数组对象.
Java练习_第六天
OceanStar的博客
02-03 394
1.写出一维数组初始化的两种方式 动态初始化：数组声明为数组元素分配空间额赋值的操作分开进行 int [] arr = new int[3]; // 数组是引用类型，它的元素相当于类的成员变量，因此数组已经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化 arr[0] = 3; arr[1] = 4; arr[2] ...
JAVA基础篇（07）：引用数据类型之数组
綦枫Maple的博客
09-04 1010
引用数据类型-数组 引用数据类型包含类、接口和数组类型，还有一种特殊的null类型。这里我们讲数组。 数组的声明 一个数组只能存储一种类型的数据，如int型数组只能存int型数据。 数组是一种引用数据类型，如int是基本数据类型，但int[ ]就是引用数据类型了。 在定义数组三要素：变量类型，数组名，数组长度。 Java中声明一个数组的方式有两种： type[ ] arrayName type ...
JAVA数组----引用数据类型
Calm的博客
11-27 1577
1.数组初始化 1.1 动态初始化（声明并开辟空间） 数组类型[] 数组名称 = new 数组类型[长度] 例：开辟一个长度为5的字符型数组： char[] arr = new char[5]; 数组是通过下标索引来取得元素，下标默认从0开始，数组下标超过数组长度就会发生数组越界异常（属于运行时异常）。 数组中每个元素都有默认值，默认值是该数组的类型默认值 数组名称.length：取得数组长度...
集合——对象数组(引用数据类型数组)
beyond谚语的博客
07-30 740
案例：我有5个学生，请把这个5个学生的信息存储到引用数据类型数组中，并遍历数组，获取得到每一个学生的信息。 思路分析：首先，想要创建学生对象，就得有学生这个类，所以，首先创建一个包(package com.wsq.bean)，在包里创建一个Student类；然后再创建引用数据类型数组(即用Student这个类去创建一个数组) 代码如下： package com.wsq.bean; //定...
数组是引用类型（基本类型变量与引用类型变量的区别）
AXiYa_Ari的博客
11-08 2891
二、基本类型变量与引用类型变量的区别 1、基本类型变量 1、概念：基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值； 2、举例 //基本类型变量 int a=10; int b=20; 2、引用类型变量 1、概念：引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。(类似与C语言中的指针) 2、举例 //引用类型的变量 String s="1234"; int[] array={1,2,3,4,5}; ...
Java&Android学习路线图：从入门到精通
"该资源提供了一份详尽的Java和Android学习路线图，旨在帮助初学者系统地学习这两个领域的知识。路线图涵盖了从基础到高级的各种技术，包括Java应用开发、Android游戏开发、核心Java概念、JavaWeb开发以及C语言编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值