Java学习路线-3：数组-天翼云

七、数组的定义与使用

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学习路线-3：数组

Java学习路线-3：数组

七、数组的定义与使用

25 数组的基本定义

26 数组引用传递分析

27 foreach输出

28 二维数组

29 数组与方法

30 数组排序案例分析

31 数组转置案例分析

32 数组相关类库

33 方法可变参数

34 对象数组

八、引用传递实际应用

35 类关联结构

36 自身关联

37 合成设计模式

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

39 综合实战：一对多映射

40 综合实战：多对多映射

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

相关文章

Java之Ajax技术

Java后端机器学习库应用：从Weka到Deeplearning4j

Java后端数据备份与恢复：策略与实践

Java后端微服务通信：gRPC与Thrift框架对比

队列，数组实现

Java后端服务端渲染与客户端渲染：SSR与CSR的权衡

java实现单链表的创建、增、删、改、查

Java学习构造方法之标准类制作

[Java 常用类库]:PropUtils 属性文件类

Python数据分析与展示：matplotlib绘图库入门-6

作者介绍

最新文章

Java之Ajax技术

Java后端机器学习库应用：从Weka到Deeplearning4j

队列，数组实现

Java学习构造方法之标准类制作

[Java 常用类库]:PropUtils 属性文件类

Python数据分析与展示：matplotlib绘图库入门-6

热门文章

Java线程同步synchronized wait notifyAll

Android/Java判断字符串String是否为float浮点数或double类型

Java/Android Annotation注解/注入（二）

Java小数点数字和百分号数字之间的转换

Java switch case语句

Java的自带注解Annotation(一)

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

Java千问19：Java位运算经典应用(三)

Java-技术专区-深入理解SPI机制

重学GoLang之通过刷LeetCode简单题来学习Go语言基础语法

尽可能贴合国内Spring应用场景的“二进制奶茶店”——《学透Spring：从入门到项目实战》

深入探究Go语言中的数据结构

【Java并发编程】之四：守护线程与线程阻塞的四种情况