目录
第一节、什么是数组
程序 = 算法 + 数据结构
数据结构：把数据按照某种特定的结构保存，设计一个合理的数据结构是解决问题的关键。
数组:最基本的数据结构
数组的特定结构: !!!相同类型组成元素集合!!!。
通过元素的下标进行访问，且下标从0开始，最大元素下标为[数组长度-1]
第二节、数组定义
数据类型[] 数组名 = new 数据类型[数组长度]；
//1.数组的定义 : 数据类型[] 数组名； ----数据类型 数组名[];
int[] arr; //数组的定义
int a[];第三节、数组的初始化
一.基本类型数组默认元素值
-
整型: 初始值为0
-
浮点型: 初始值为0.0
-
字符型: 空字符
-
布尔型: 初始值 false
一.数组的初始化
1.数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr1 = new int[5];
arr1[2]=2;
System.out.println(arr1[2]); 2.数据类型[] 数组名 = {元素值列表};弊端：没法分开赋值，必须在声明时对其初始化，不建议用
int[] arr2 = {1,2,3,4,5,6,7};
int[] arr3;
arr3 = {1,2,3}; //会报错，因为没有声明了数组arr3，没有开辟内存空间3.数据类型[] 数组名= new 数据类型[]{元素列表}；
int[] arr4;
arr4 = new int[]{1,2,3};
int[] arr5 = new int[]{1,2,3,4};第四节、数组的访问
一.数组长度：
int lenth = arr5.length;
System.out.println(lenth);
System.out.println(arr5.length);
//通过下标访问数组元素
arr5[1] = 4; //存值
System.out.println(arr5[1]);二.访问
例：生成一个长度为10随机整数（0-100）数组
//1.定义数组
int[] num = new int[10];
//2.赋值随机数0-100整数
/*
Math.random()0-1内的随机数
*/
for (int i = 0;i <= num.length;i ++){
num[i] = (int)(Math.random()*100);
}
//3.通过下标访问下标5的数组元素
System.out.println(num[5]);第五节、数组的遍历
一.普通for循环
//普通for循环
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]+" ");
}二.增强for循环：
for(变量：数组名){
System.out.println(变量);
}- 增强for循环底层是迭代器
- 数组是特殊的集合，不是Collection继承关系中
1.增强for循环在遍历数组时会转换为基本for循环
for (int i : arr4){
System.out.println(i + " ");
}转换为普通for循环：
for (int i = 0; i < arr4.length; i++) {
System.out.println(arr4[i]+" ");
}2.增强for循环在迭代器集合时用的迭代器
List <Integer > lists = new ArrayList<Integer>();
lists.add(1);
lists.add(2);
lists.add(3);
for (Integer i : lists){
System.out.println(i + " ");
}第六节、数组总结
1.数组:最基本的数据结构，是相同类型组成元素集合!!!。
通过元素的下标进行访问，且下标从0开始，最大元素下标为[数组长度-1]
2. 数组定义：数据类型[] 数组名 = new 数据类型[数组长度]；
3.基本类型数组默认元素值
- 整型: 初始值为0
- 浮点型: 初始值为0.0
- 字符型: 空字符
- 布尔型: 初始值 false
4.数组初始化：
（1）数据类型[] 数组名 = new 数据类型[数组长度];
（2） 数据类型[] 数组名 = {元素值列表};弊端：没法分开赋值， 必须在声明时对其初始 化，不建议用
（3）数据类型[] 数组名= new 数据类型[]{元素列表}；
5.数组的访问：
- 获取数组的长度：数组名.length
- 用下标访问数组的元素
6.数组的遍历：
（1）普通for循环
（2）增强for循环
第七节、数组的复制
数组的复制：两种方法，实际上只有一种方法
一.System.arrayCopy（）方法
-
有五个参数： @NotNull Object src (原数组),int srcPos（原数组位置）,@NotNull Object dest （目标数组）,int destPos （原数组的起始位置）,int lenth （复制的长度)。
public static void arraycopy(
@NotNull Object src (原数组),
int srcPos（原数组位置）,
@NotNull Object dest （目标数组）,
int destPos （原数组的起始位置）,
int lenth （复制的长度) )-
当目标数组的长度小于要copy的长度： 数组下标越界异常
-
当目标数组的长度大于要copy的长度： 会用默认值填充
-
当改变目标数组元素时，原数组数组元素不会发生变化，copy后的元素是新内存空间， 不会和原数组共用一块空间
-
当目标数组为同一个数组时，会对原数组的值重新覆盖，长度不变
import java.util.Arrays;
public class TestArray2 {
public static void main(String[] args) {
//1.System.arrayCopy
//copy:1~3
int[] arr1 = {1,5,6,8,9};
int arr2[] = new int [5];
System.arraycopy(arr1,1,arr2,0,3);
System.out.println("arr1"+ Arrays.toString(arr1)); //1,5,6,8,9,
System.out.println("arr2"+Arrays.toString(arr2));
//5,6,8,0,0,
}
}二.System.copyof（）
-
两个参数：原数组，复制长度，会返回一个新数组
数组 = Array.copyof(原数组，复制长度)-
当复制的长度小于原数组的长度时，则截取
-
当复制的长度大于原数组的长度时，则扩容
-
当出现截取或扩容时，原数组的长度没有变，一旦创建不会改变。
-
Array.copyof()底层新建了一个数组，调用了System.arrayCopy()复制后，返回了一个新数组，因此长度变了。但原数组的长度没有变，一旦创建不会改变。
public class TestArray2{
public static void main(String[] args){
//复制原数组
int[] arr1 = {1,5,6,8,9};
arr1 = Array.copyof(arr1,5);
System.out.println(arr1);
//1.当复制的长度小于原数组的长度时，则截取
arr1 = Array.copyof(arr1,4);
System.out.println(arr1); //{1，5，6，8}
//2.当复制的长度大于原数组的长度时，则扩容
arr1 = Array.copyof(arr1,6);
System.out.println(arr1); /
}
}第八节、数组的排序
这里先学习最简单的冒泡排序
一、冒泡排序的概念：
冒泡排序（Bubble Sort），实质就是把小（大）的元素往前（后）调。重复比较要排序的元素，依次比较两个相邻的元素，按照排列顺序，把他们交换过来，直到没有相邻元素需要交换，就已经排序完成。
二、算法原理：
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数，下一轮就忽略该最大数，对之前的元素进行比较。
-
所有的元素重复以上的步骤，除了每一轮的最后一个大值。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
三、冒泡的判断条件：
条件判断：
- 外层： i < length -1
- 内层： j < length - i - 1
交换：
- t = arr[j];
- arr[j] = arr [j + 1];
- arr[j + 1] = t;
import java.util.Arrays;
public class TestArray3 {
public static void main(String[] args) {
//1.冒泡排序
//定义一个长度为15的随机数组
int[] arr = new int[15];
int t;
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random()*100);
}
System.out.println("排序前："+ Arrays.toString(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]){
//交换元素
t = arr[j];
arr[j] = arr [j + 1];
arr[j + 1] = t;
}
}
}
System.out.println("排序后："+Arrays.toString(arr));
}
}第九节、练习
要求：
- 1．随机产生一个长度为20的数组(整数0-200内)
- 2. 正序输出
- 3．逆序输出
- 4．不采用排序的方式找到当前数组的最大值
- 5．将最大值和数组最后一个元素互换
- 6.删除最后一个元素--最大值
- 7．对数组元素从大到小排序后打印输出
package com.hqyj.javacode.array;
import java.util.Arrays;
public class TestArraywork1 {
public static void main(String[] args) {
//随机产生一个长度为20的随机数组（整数0-200）
int[] arr = new int[20];
int max = arr[0];
int flag = 0;
for (int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random()*200);
}
//正序输出
System.out.print("正序输出：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
//逆序输出
System.out.print("逆序输出：");
for (int i = arr.length -1; i >= 0; i--) {
System.out.print(arr[i] + " ");
}
System.out.println();
//不采用排序的方式找到当前数组的最大值
for (int i = 1; i < arr.length ; i++) {
if (max < arr[i]){
max = arr[i];
flag = i;
}
}
System.out.println("最大值为："+max);
//将最大值和数组最后一个元素互换
int temp = arr[flag];
int num = arr.length-1;
arr[flag] = arr[num];
arr[num] = temp;
System.out.print("将最大值和数组最后一个元素互换后为：");
System.out.println(Arrays.toString(arr));
//删除最后一个元素----最大值
arr = Arrays.copyOf(arr,arr.length-1);
System.out.print("删除最后元素后：");
System.out.println(Arrays.toString(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]){
//交换元素
temp = arr[j];
arr[j] = arr [j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println("从大到小排序后："+Arrays.toString(arr));
}
}
351
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
