Java学习笔记——day03

目录

• 数组
• Arrarys类
• 冒泡排序

1. 数组

1.1数组的定义

数组是相同类型数据的有序集合。

比如之前我们要存储一个int类型的数需声明一个变量，那么如果现在要存储100个int类型的数，岂不是要声明100个变量，为了避免这种麻烦，数组应需而生。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。

1.２数组特点

１. 数组元素必须是相同类型，不允许出现混合类型。元素的类型可以是java 支持的任意类型，包括基本类型和引用类型。
２. 数组的元素在堆内存中被分配空间，并且是连续分配的
３. 使用new 关键字对数组进行 内存的分配。每个元素都会被jvm 赋予默认值。

默认规则：整数：0 浮点数：0.0 字符：\u0000 布尔：false 引用数据类型：null。

４. 数组的元素都是有序号的，序号从0开始。

1.３数组的声明

1.3.1动态方式

注：指定数组的长度；

• 格式

数据类型[] 数组名字 = new 数据类型[长度];

注：1.[] : 表示数组。
    2.数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
    3.new：关键字，创建数组使用的关键字。
    4.数据类型： 看创建的数组用来存储什么数据类型。
    5.[长度]：数组的长度，表示数组容器中可以存储多少个元素。

• 实例

//定义可以存储10个整数的数组容器，代码如下：
int[] array = new int[10];

1.3.1静态方式

注:指定数组的元素.

• 格式

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

• 实例

//定义存储1~10整数的数组容器。
int[] array = new int[]{1,2,3,4,5,6,7,8,9,10};

注:1.如果使用静态方式创建数组,那么系统会根据元素的个数自动计算数组的长度.
   2.静态方式创建数组右边的中括号里面不能写长度.
   3.静态方式的省略格式创建数组不能先声明后赋值,只能声明的同时直接赋值

1.4 数组的遍历

对于数组遍历，Java给出了一种专用for循环，增强for循环，只能用来遍历数组和集合。

• 格式

 for(遍历出来的每一个值: 要遍历的数组)      

• 实例

		 int[] array = new int[100];
         for (int i : array) {
            System.out.println(i);
        }      

1.5 数组的常见问题

• 角标越界：当访问到数组中不存在的角标时；

int[] array = new int[5];
System.out.println(array[6]);
//ArrayIndexOutOfBoudsException(角标越界)

• 空指针异常：当引用变量没有任何实体指向时，继续指向实体。

array = null;
System.out.println(array[0]);
//NullPointerException

1.6 数组的优缺点

• 优点：

  • 可以保存若干个数据；
  • 随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）。

• 缺点：

  • 数组的元素的类型必须一致。元素类型必须一致；
  • 数组定长，不能自动扩容；

2. Arrays类

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

2.1 打印数组

• 调用格式

 Arrays.toString(arr)

• 实例

import java.util.Arrays;
public class Demo06 {
    public static void main(String[] args) {
        int[] array = {1, 4, 3, 9, 2, 6, 7};
        String str = Arrays.toString(array);
        System.out.print(str);
    }
}

2.2 数组元素的排序 Arrays.toString(arr)

• 调用格式

 Arrays.sort(arr)

• 实例

import java.util.Arrays;
public class Demo07 {
    public static void main(String[] args) {
        int[] array = {1,5,788,245,77687,};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

3. 冒泡排序

3.1 原理

每次比较两个相邻的元素，将较大的元素交换至右端。

3.2 思路

每次冒泡排序操作都会将相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足，就交换这两个相邻元素的次序，一次冒泡至少让一个元素移动到它应该排列的位置，重复N次，就完成了冒泡排序。

3.3 动态演示

3.4 代码实现

//冒泡排序法
    public static int[] bubbleSort(int[] array)
    {
        int temp = 0;
        //外层循环，判断冒泡排序要走几次
        for (int i = 0; i < array.length - 1; i++)
        {
            //内层循环。每走一次，就会出来一个最大的
            for (int j = 0; j < array.length - 1 - i; j++)
            {
                //如果后一个数大于前一个数，交换位置
                if(array[j+1] < array[j])
                {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }