javase学习——数组
1. 一维数组
1.1 声明
- 数组的声明，就是要确定：
（1）数组的维度：在Java中数组的标点符号是[]，[]表示一维，[][]表示二维
（2）数组的元素类型：即创建的数组容器可以存储什么数据类型的数据。元素的类型可以是任意的Java的数据类型。例如：int, String, Student等
（3）数组名：就是代表某个数组的标识符，数组名其实也是变量名，按照变量的命名规范来命名。数组名是个引用数据类型的变量，因为它代表一组数据。
//比如，要存储一个小组的成绩
int[] scores;
// System.out.println(scores);//未初始化不能使用
//比如，要存储一组字母
char[] letters;
//比如，要存储一组姓名
String[] names;
//比如，要存储一组价格
double[] prices;
1.2 初始化
1.2.1 静态初始化
- 一维数组静态初始化格式1：
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写
- 一维数组静态初始化格式2：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3,4,5};//正确
int[] arr;
arr = new int[]{1,2,3,4,5};//正确
1.2.2 动态初始化
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
或
数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];
int[] arr = new int[5];
int[] arr;
arr = new int[5];
int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[]中指定元素个数了
1.3 使用
1. 数组的长度 数组名.length
2. 数组的元素 数组名[索引/下标]
3. 数组的下标范围 Java中数组的下标从[0]开始，下标范围是[0, 数组的长度-1]，即[0, 数组名.length-1]
int[] arr = {1,2,3,4,5};
System.out.println("arr数组的长度：" + arr.length);
System.out.println("arr数组的第1个元素：" + arr[0]);//下标从0开始
System.out.println("arr数组的第2个元素：" + arr[1]);
System.out.println("arr数组的第3个元素：" + arr[2]);
System.out.println("arr数组的第4个元素：" + arr[3]);
System.out.println("arr数组的第5个元素：" + arr[4]);
//修改第1个元素的值
//此处arr[0]相当于一个int类型的变量
arr[0] = 100;
System.out.println("arr数组的第1个元素：" + arr[0]);
1.4 遍历
数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。
遍历也是数组操作中的基石。for循环与数组的遍历是绝配。
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性，输出结果是5
System.out.println("数组的长度：" + arr.length);
//遍历输出数组中的元素
System.out.println("数组的元素有：");
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
1.5 数组元素默认值
| 数组元素类型 | 元素默认初始值 |
|---|---|
| byte | 0 |
| short | 0 |
| int | 0 |
| double | 0.0 |
| char | 0或者\u0000 |
| boolean | false |
| 引用数据类型 | null |
1.6 角标越界异常
当访问数组元素时，下标指定超出[0, 数组名.length-1]的范围时，
就会报数组下标越界异常：ArrayIndexOutOfBoundsException。
2. 一维数组常见算法
2.1 求和、求均值、统计个数等
public class Test08ArrayElementSum {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
sum += arr[i];
}
double avg = (double)sum/arr.length;
System.out.println("sum = " + sum);
System.out.println("avg = " + avg);
}
}
public class Test09ArrayElementMul {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
result *= arr[i];
}
System.out.println("result = " + result);
}
}
public class Test10ArrayElementEvenCount {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//统计偶数个数
int evenCount = 0;
for(int i=0; i<arr.length; i++){
if(arr[i]%2==0){
evenCount++;
}
}
System.out.println("evenCount = " + evenCount);
}
}
2.2 找最值
思路：
（1）先假设第一个元素最大/最小
（2）然后用max/min与后面的元素一一比较
public class Test11ArrayMax {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){//此处i从1开始，是max不需要与arr[0]再比较一次了
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("max = " + max);
}
}
拓展1：找最值及其第一次出现的下标位置
思路：
（1）先假设第一个元素最大/最小
（2）用max/min变量表示最大/小值，用max/min与后面的元素一一比较
（3）用index时刻记录目前比对的最大/小的下标
public class Test12MaxIndex {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//找最大值以及第一个最大值下标
int max = arr[0];
int index = 0;
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
index = i;
}
}
System.out.println("max = " + max);
System.out.println("index = " + index);
}
}
拓展2：找最值以及所有最值出现的下标
有一种情况是元素是重复的，那么最大值就有多个。
思路：
（1）先找最大值
①假设第一个元素最大
②用max与后面的元素一一比较
（2）遍历数组，看哪些元素和最大值是一样的
public class Test13AllMaxIndex {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9,9,3};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("最大值是：" + max);
System.out.print("最大值的下标有：");
//遍历数组，看哪些元素和最大值是一样的
for(int i=0; i<arr.length; i++){
if(max == arr[i]){
System.out.print(i+"\t");
}
}
System.out.println();
}
}
2.3 元素查找
2.3.1 顺序查找
public class Test14ArrayOrderSearch {
//查找value第一次在数组中出现的index
public static void main(String[] args){
int[] arr = {4,5,6,1,9};
int value = 1;
int index = -1;
for(int i=0; i<arr.length; i++){
if(arr[i] == value){
index = i;
break;
}
}
if(index==-1){
System.out.println(value + "不存在");
}else{
System.out.println(value + "的下标是" + index);
}
}
}
2.3.2 二分查找
import java.util.Scanner;
public class Test15ArrayBinarySearch {
public static void main(String[] args){
//数组一定是有序的
int[] arr = {8,15,23,35,45,56,75,85};
Scanner input = new Scanner(System.in);
System.out.print("请输入你要查找的值：");
int target = input.nextInt();
int index = -1;
for(int left = 0,right = arr.length-1; left<=right; ){
//int mid = (left+right)/2;
int mid = left + (right-left)/2;
if(arr[mid] == target){
index = mid;
break;
}else if(target > arr[mid]){
//说明target在[mid]右边
left = mid+1;
}else{
//说明target
right= mid-1;
}
}
if(index!=-1){
System.out.println("找到了，下标是"+index);
}else{
System.out.println("不存在");
}
}
}
2.4 反转
数组对称位置的元素互换
public class Test17ArrayReverse {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println("反转之前：");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//反转
//左右对称位置交换
for(int left=0,right=arr.length-1; left<right; left++,right--){
//首 与 尾交换
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
System.out.println("反转之后：");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2.5 排序
常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)
2.5.1 直接选择排序
直接选择排序
思想：每一轮找出本轮的最大值/最小值，然后看它是否在它应该在的位置。
如果不在正确的位置，就与这个位置的元素交换。
过程：arr{6,9,2,9,1} 目标：从小到大
第1轮：最大值是9，它现在在arr[1]，它应该在arr[4]，不对，交换arr[1]和arr[4]，{6,1,2,9,9}
第2轮：最大值是9，它现在在arr[3]，它应该在arr[3]，对，不动
第3轮：最大值是6，它现在在arr[0]，它应该在arr[2]，不对，交换arr[0]和arr[2]，{2,1,6,9,9}
第4轮：最大值是2，它现在在arr[0]，它应该在arr[1]，不对，交换arr[0]和arr[1]，{1,2,6,9,9}
过程：arr{6,9,2,9,1} 目标：从小到大
第1轮：最小值是1，它现在在arr[4]，它应该在arr[0]，不对，交换arr[4]和arr[0]，{1,9,2,9,6}
第2轮：最小值是2，它现在在arr[2]，它应该在arr[1]，不对，交换arr[2]和arr[1]，{1,2,9,9,6}
第3轮：最小值是6，它现在在arr[4]，它应该在arr[2]，不对，交换arr[4]和arr[2]，{1,2,6,9,9}
第4轮：最小值是7，它现在在arr[3]，它应该在arr[3]，对，不动
public class Test18SelectSort{
public static void main(String[] args){
int[] arr = {6,9,2,9,1};
//直接选择排序，轮数 = 数组的元素总个数-1
/*
arr.length=5
i=0
i=1
i=2
i=3
*/
for(int i=0; i<arr.length-1; i++){
//找出本轮的最小值，及其下标
/*
i=0，第1轮，查找的范围是[0,4]，一开始假设arr[0]最小
i=1，第2轮，查找的范围是[1,4]，一开始假设arr[1]最小
i=2，第3轮，查找的范围是[2,4]，一开始假设arr[2]最小
i=3，第4轮，查找的范围是[3,4]，一开始假设arr[3]最小
int min = arr[i];
*/
int min = arr[i];
int index = i;
//用[i+1, arr.length-1]范围的元素与min比较
for(int j=i+1; j<arr.length; j++){
if(arr[j] < min){
min = arr[j];
index = j;
}
}
//判断min是否在它应该在的位置
/*
i=0，第1轮，最小值应该在arr[0]位置，它现在在arr[index]位置
i=1，第2轮，最小值应该在arr[1]位置，它现在在arr[index]位置
i=2，第3轮，最小值应该在arr[2]位置，它现在在arr[index]位置
i=3，第4轮，最小值应该在arr[3]位置，它现在在arr[index]位置
最小值应该在arr[i]位置, 如果index!=i，说明它不在应该在的位置，
就交换arr[i]和arr[index]位置
*/
if(index!=i){
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
//完成排序，遍历结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]+" ");
}
}
}
2.5.2 冒泡排序
Java中的经典算法之冒泡排序（Bubble Sort）
原理：比较两个相邻的元素，将值大的元素交换至右端。
思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。
即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。
然后比较第2个和第3个元素，将小数放到前面，大数放到后面。
如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。
重复第一趟步骤，直至全部排序完成。
public class Test19BubbleSort{
public static void main(String[] args){
int[] arr = {6,9,2,9,1};
//目标：从小到大
//冒泡排序的轮数 = 元素的总个数 - 1
//轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
//外循环控制 轮数，内循环控制每一轮的比较次数和过程
for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
for(int j=0; j<arr.length-i; j++){
//希望的是arr[j] < arr[j+1]
if(arr[j] > arr[j+1]){
//交换arr[j]与arr[j+1]
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//完成排序，遍历结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i]+" ");
}
}
}