10_Java筑基之数组
一. 数组
回顾数据类型:
(1). 基本类型:
byte short int long float double char boolean
(2). 引用类型:
类 数组 接口 枚举 注解
回顾:
变量: 内存中的一块存储空间,存储的就是常量.
特点: 一个变量只能存储一个数据,不能存储多个.
需求: 统计一个班级中30个学生的java成绩.
解决方式1: 使用变量存储,需要声明30个变量:
int java1=90;
int java2=80;
...
解决方式2: 使用数组.
1. 什么是数组
数据的组合,不止一个数据,包含多个数据,数组就是一个变量.
2. 数组声明和初始化
2.1 声明:
方式一: 数据类型[] 数组名;
例如 String[] names;
方式二: 数据类型 数组名[];
例如: String names[];
推荐使用方式一,C#等越来越多的语言已经不支持方式二定义数组.
2.2 初始化:
Java中的数组必须先初始化,然后才可以使用,所谓初始化,就是为数组中的数组元素分配内存空间,并为每个数组 元素赋初始值.
3. 静态初始化
初始化时由程序员指定每个数组元素的初始值,由系统计算数组长度.
语法: 数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,....};
可简写为: 数组元素类型[] 数组名 = {元素0，元素1,....};
说明: 任何一个变量都得有自己的数据类型,这里的arr表示数组变量名称,int表示数组中元素的类型,int[]才是数组类型.
注意: 简写静态初始化只能一条语句完成,不能分割成两条语句.
3.1 代码实现:
/*
静态初始化: 由我们指定元素的初始值,由系统计算长度或者元素的个数.
*/
//1.创建一个整型类型数组
int[] arr = new int[]{1,10,20,30};
//简化写法
int[] arr1 ={1,10,20,30};
//2.创建一个字符串类型数组
String[] arr2 = new String[]{"aaa","bbb","ccc"};
//简化写法
String[] arr3 = {"aaa","bbb","ccc"};
//3.创建一个字符类型数组
char[] arr5 = new char[]{'a','b','c'};
//简化写法
char[] arr5 ={'a','b','c'};
4. 动态初始化
初始化时程序员只指定数组长度,由系统为数组元素分配初始值.
语法:
元素类型[] 数组名 = new 元素类型[元素个数或者数组长度];
系统对初始值分配规则如下:
a. 整数型为0;
b. 浮点型为0.0;
c. 字符型为‘\u0000’(不同的系统平台显示结果不同);
d. 布尔类型为false;
e. 引用类型为null.
4.1 代码实现:
/*
动态初始化: 初始化时由程序员指定数组的长度,系统负责分配元素的初始值.
*/
int[] array1 = new int[5];//初始值为0
String[] array2 = new String[3];//初始值为null
char[] array3 = new char[10];//初始值为\u0000
注意:
在初始化数组时,不要静态初始化和动态初始化同时使用.也就是说,不要在进行数组初始化时,既指定数组的长度,也为每个数组元素分配初始值.
5. 数组的使用
5.1 通过下标访问指定元素
注意
1.Java语言的数组索引(下标、角标)是从0开始的;
2.不要超出索引的范围,如果超出范围会出现异常java.lang.ArrayIndexOutOfBoundsException
代码实现:
//使用静态初始化的方式定义一个数组
//数组中可以存放重复的数据.
int[] arr1 = new int[]{2,65,76,83,32,5,5};
//1.访问数组中的元素
//格式: 数组名称[下标] 表示获取指定下标所对应的值.
//需求: 获取下标3对应的元素
int num1 = arr1[3];
System.out.println(num1);//83
System.out.println(arr1[3]);//83
5.2 获取数组元素的个数
在Java中,所有的数组都提供了一个length属性,通过这个属性可以访问到数组的长度或者数组中元素的个数.
代码实现
//2.获取数组中的元素个数或者数组的长度
//格式: 数组名称.length;
int len = arr1.length; System.out.println("数组arr1的长度为:" + len);
5.3 修改数组元素的值
代码实现:
//3.修改数组元素的值
int num2 = arr1[6];
System.out.println(num2);
//格式: 数组名称[下标] = 被修改之后的值.
//注意: 不管是静态初始化还是动态初始化,都可以采用这种方式修改元素的值;
arr1[6] = 100;
System.out.println(arr1[6]);//100
5.4 遍历数组
依次访问数组中的每一个元素,获取每个下标对应的元素值.
方式一:简单for循环;
方式二:增强for循环(foreach)无法使用下标.
代码实现:
//遍历数组
int[] arr1 = new int[]{2,65,76,83,32,5,5};
int n0 = arr1[0];
int n1 = arr1[1];
int n2 = arr1[2];
int n3 = arr1[3];
int n4 = arr1[4];
int n5 = arr1[5];
int n6 = arr1[6];
//1> 简单for循环
//i表示下标，0~arr1.length
for(int i = 0;i < arr1.length;i++) {
int n = arr1[i];
System.out.println(n);
}
/*
2> 增强for循环【foreach】
这是JDK1.5之后新增的API.
优点:用于遍历数组和集合,无需通过数组下标,就可以直接访问数组或者集合中的元素.
语法:
for(元素数据类型 变量名 : 数组名称){
System.out.println(变量名);
}
*/
//底层工作原理:根据下标获取数组元素
for(int num : arr1){
System.out.println("增强for循环的结果:"+num);
}
/* 两种遍历方式的选择: 不需要知道下标,只需要获取元素值,则采用增强for循环*/
//需求:打印下标为偶数的元素值【只能采用简单for循环】 for(int i = 0;i < arr1.length;i++) {
if(i % 2 == 0) {
int n = arr1[i];
System.out.println(n);
}
}
上机练习:
键盘录入学生java成绩,并把成绩保存在数组中,然后计算总分和平均分.
public static void main(String[] args){
Scanner input=new Scanner(System.in);
System.out.println("请输入班级人数");
int count=input.nextInt();
int[] score=new int[count];
for (int i = 0; i < score.length; i++) {
System.out.println("请输入第"+(i+1)+"个人的java成绩");
score[i]=input.nextInt();
}
System.out.println("-----------------");
int sum=0;//总分
double avg=0;//平均分
for (int n : score){
sum=sum+n;
}
avg=(double)sum/count;
System.out.println("总分是:"+sum);
System.out.println("平均分是:"+avg);
}
6. 数组的内存分配
java内存:
栈: 存储基本类型的数据和引用类型的地址.
特点: 先进后出,一般空间比较小,存取速度较快.
堆: 存储引用类型的数据.
特点: 空间比较大,存储速度相对较慢.
方法区: 存储字符串常量池,静态数据,代码和类的元数据.
数组属于引用类型,数组引用变量只是一个引用,这个引用变量可以指向任何有效的内存空间,只有当这个引用指向有效的空间时,才可以通过引用去操作真正数组中的元素.
结论: 数组的引用变量存储在栈空间中,而真正的数组数据存储在堆空间在中.
代码实现:
class ArrayUsageDemo04{
public static void main(String[] args){
//图1.使用静态初始化的方式初始化一个数组a
int[] a = {5,7,20};
System.out.println("a的长度为:" + a.length);//3
int num =8;
System.out.println("num:"+num);
//图2
int[] b=new int[4];
System.out.println("b的长度是:"+b.length);
b=a;
System.out.println("b的长度是:"+b.length);
}
}
画图分析:

6. 使用数组时常见的问题
1>数组越界异常: ArrayIndexOutofBoundsException.
出现的时机: 当使用了不存在的下标时,则会出现这个错误.
数组下标范围是[0 ~ length-1].
2>空指针异常: NullPointerException.
出现的时机: 当数组的引用变量赋值为null,但是在后面的代码中使用了这个空的引用.
7. 数组的排序
7.1 冒泡排序
排序思路: 比较两个相邻的下标对应的元素,如果符合条件就交换位置(最值出现在最后位).
画图分析:
代码实现
class ArraySortedDemo01{
public static void main(String[] args){
int[] arr = {23,54,65,3,5,2,87}; //以升序为例
//外层循环:控制比较的轮数
for(int i =0;i < arr.length -1;i++){
//内层循环:控制每一轮比较的次数和参与比较的下标
for(int j=0;j<arr.length-1-i;j++){
if(arr[j] > arr[j + 1]){
//交换位置
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int num:arr) {
System.out.println(num);
}
}
}
7.2 选择排序
排序思路:固定一个下标,然后拿这个下标对应的值依次和后面的元素进行比较.
画图分析:

代码实现:
class ArraySortedDemo02{
public static void main(String[] args){
int[] arr = {23,54,65,3,5,2,87};
//以升序为例
//外层循环:控制比较的轮数
for(int i = 0;i< arr.length - 1;i++){
//内层循环:控制每一轮比较的次数,参与比较的下标
for(int j=i+ 1;j<arr.length;j++){
//交换位置
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for(int num:arr) {
System.out.println(num);
}
}
}
8. 数组的查找
8.1 顺序查找
查找思路: 遍历这个数组,依次把每一位元素和要查找的数据进行比较.
代码实现:
class ArraySearchDemo01{
public static void main(String[] args){
int[] arr = {23,54,65,3,5,2,87};
//需求:查找65在数组中的位置
int key = 65;
for(int i = 0;i <arr.length;i++) {
if(key == arr[i]) {
System.out.println(i);
}
}
}
}
8.2 二分法查找
查找思路: 前提是数组是有序(升序或者降序)的,通过折半来缩小查找范围,提高查找效率.
将待查找的元素与中间下标对应的元素比较,如果大于中间下标对应的元素,则去右半部分查找.
画图分析:

代码实现:
class ArraySearchDemo02{
public static void main(String[] args){
int[] arr={12,43,54,65,87,88,90,343};
//待查找的元素
int key = 88;
//相应的下标 int left = 0;
int right = arr.length - 1;
while(left <= right) {//中间下标
//取整
int middle = (left + right)/ 2;
if(arr[middle] > key) {
right = middle - 1;
} else if(arr[middle] < key) {
left = middle + 1;
} else {
System.out.println(middle);
break;
}
}
}
}
三. Arrays工具类
作用: 主要用于对数组进行排序,查找,填充,比较等的操作.
Arrays工具类存在于java.util包下,所以使用的第一步就是导包: import java.util.Arrays;
1. 演示代码
//演示Arrays工具类的使用
package com.syc.day07;
import java.util.Arrays;
/*
* Arrays工具类的使用
* 1 二分查找
* 2 排序
* 3 复制
* 4 填充
* 5 把数组转成字符串
*/
public class Demo1 {
public static void main(String[] args) {
//binarySearch();
//sort();
//copy();
//fill();
toStr();
}
//binarySearch 二分查找
public static void binarySearch() {
int[] arr=new int[] {5,8,10,20,65,100};
int result=Arrays.binarySearch(arr,22);
if(result>=0){
System.out.println("找到了");
}else{
System.out.println("没找到 "); }
}
//排序
public static void sort() {
int[] arr=new int[] {12,8,100,2,9};
Arrays.sort(arr);
System.out.println("排序之后:");
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
//复制
public static void copy() {
int[] arr=new int[] {12,8,100,2,9};
int[] arr2=Arrays.copyOf(arr,arr.length);
for(int i=0;i<arr2.length;i++) {
System.out.println(arr2[i]);
}
}
//填充
public static void fill() {
int[] arr=new int[] {12,8,100,2,9};
Arrays.fill(arr, 10);
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
//把数组转成字符串
public static void toStr() {
int[] arr=new int[] {12,8,100,2,9};
String s=Arrays.toString(arr);
System.out.println(s);
}
}
四. 可变参数
1. 不定长参数
在设计方法时,方法的形参的个数是不确定的.
语法: 类型... 变量名称
例如: int... num
好处: 不用创建数组,直接写数组元素.
代码实现:
package com.syc.day07;
/*
* 可变参数 * int...
* 好处: 不用创建数组,直接写数组元素.
* 注意事项:
* 1.一个方法只能有一个可变参数;
* 2.可变参数只能方法参数列表最后.
*/
public class Demo4 {
public static void main(String[] args) {
//调用
//int[] nums= {10,4,8,20};
//sort(nums);
//实际运行是,把这些数据变成数组
sort(10,4,8,20,1,2);
}
public static void sort(int a,int... arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]) {
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
五. 总结
1. 数组的基本使用
(1). 先声明;
(2). 初始化
静态初始化,不用指定长度,直接赋值元素;
动态初始化,需要指定长度,数据默认值;
(3). 声明同时也可以初始化.
2. 数组的使用
通过下标获取元素,下标的范围0-长度-1;
获取数组的长度,length;
修改数组元素: nums[0]=10;
遍历:
(1).for;
(2).增强for,不能使用下标.
3. 排序: 冒泡排序/选择排序;
4. 查找: 顺序查找/二分法查找;
5. Arrays工具类的使用;
6. 可变参数.
