数组(变量,引用数据类型 null)
变量:
int score = 90;
需求:
使用一个变量存储多个数据。
1.数组:
容器(大小限制). 存储相同数据类型的数据。
2.创建数组
语法:
数据类型[] 变量名(数组名) = new 数据类型[length]; 初始化数组变量
int data[] = new int[ ]{ };
获取/存储元素。用index(索引/脚标)
index值: 从 0 开始 index>=0 && index <数组.length
data[index]
遍历数组元素：
增强for循环：
for(数组元素数组类型 变量名:数组名){
//变量名就是数组里面的每一个元素
//等同于将数组里面的每一个元素赋值给了变量
}
数据类型[] 变量名(数组名) ={元素1，元素2.。。。。}； 初始化数组变量
数据类型[] 变量名(数组名); 声明变量
变量名(数组名) = new 数据类型[length];
.案例
求数组元素最值
动态录入学生个数 以及每个学生成绩 (存储数组)
package com.javasm.array;
import java.util.Scanner;
public class ArrayDemo2 {
public static void main(String[] strs) {
// String[] name = new String[2];
// String[] name1 = {"jim","tom"};
//
// System.out.println(name1[0]);
// name1[0] = "lucy";
//
// int[] nums;
// nums = new int[3];
// System.out.println(nums);
// 动态录入学生个数 以及每个学生成绩 (存储数组)
Scanner input = new Scanner(System.in);
System.out.println("录入学生个数");
int count = input.nextInt();
//创建数组
int[] scores = new int[count];
//动态录入学生的成绩
for(int index= 0,len = scores.length;index<len;index++) {
System.out.println("请录入"+(index+1)+"学生的成绩");
int score = input.nextInt();
scores[index] = score;
}
//获得成绩的最值
int max = scores[0];
int min = scores[0];
for(int index= 1,len = scores.length;index<len;index++) {
// if(scores[index]>max) {
// max = scores[index];
// }
// if(scores[index]<min) {
// min = scores[index];
// }
//三元运算符
max = (scores[index]>max)?scores[index]:max;
min = (scores[index·]<min)?scores[index]:min;
}
System.out.println(max);
System.out.println(min);
}
}
复制数组的元素到另外一个数组
package com.javasm.array;
import java.util.Arrays;
public class ArrayDemo3 {
public static void main(String[] strs) {
String[] str1 = {"hello","world"};
//将str1的元素内容复制到str2数组
String[] str2 = str1;//str1的地址值赋值给str2 共有一块内存
System.out.println(str1);
System.out.println(str2);
// String[] str3 = new String[str1.length];
// for(int index = 0,len = str3.length;index<len;index++) {
// str3[index] = str1[index];
// }
String[] str3 = Arrays.copyOf(str1, 1);
System.out.println("str3:"+Arrays.toString(str3));
System.out.println("str1："+Arrays.toString(str1));
System.out.println("str2:"+Arrays.toString(str2));
str1[0] = "abc";
System.out.println("修改之后str1："+Arrays.toString(str1));
System.out.println("修改之后str2:"+Arrays.toString(str2));
//改变str1的元素不影响str2元素 不共用一块内存
System.out.println("修改之后str3:"+Arrays.toString(str3));
}
}
比较两个数组变量数据是否一致
package com.javasm.array;
import java.util.Arrays;
public class ArrayDemo4 {
public static void main(String[] strs) {
int[] num1 = { 1, 2, 3 };
int[] num2 = { 1, 2, 3 };
// System.out.println(num1.equals(num2));//false
// System.out.println("123".equals("123"));
// // 比较num1和num2数据一致
// System.out.println(num1 == num2);// false
// System.out.println(Arrays.equals(num1, num2));
if (num1 == num2) {
System.out.println("元素数据一致");
return;
}
// 比较数组长度
int len1 = num1.length;
int len2 = num2.length;
if (len1 != len2) {
System.out.println("数组的数据不一致");
return;
}
// 长度一致
boolean flag = false;
for (int index = 0; index < len1; index++) {
if (num1[index] != num2[index]) {
System.out.println("数组的数据不一致");
return;
}else {
System.out.println("数组的数据一致");
}
flag = true;
}
// if(flag) {
// }
}
}
对数组元素排序
package com.javasm.array;
import java.util.Arrays;
public class ArraySort3 {
public static void main(String[] args) {
int[] array = { 12, 20, 6, 40 };
// 升序排列
System.out.println("排序之前：" + Arrays.toString(array));
int len = array.length;
for (int i = 1; i < len; i++) {
int temp = array[i];
int leftIndex = i - 1;
while (leftIndex >= 0 && array[leftIndex] < temp) {// 左边元素比右边还要大
array[leftIndex+1] = array[leftIndex];
leftIndex--;
}
// 当前元素填补空位
array[leftIndex + 1] = temp;
}
System.out.println("排序之后：" + Arrays.toString(array));
}
}
.Arrays java.util.*
操作数组变量的工具类。
Arrays.toString(数组名); 将数组内容转换成字符串进行输出
Arrays.copyOf(源数组,新数组长度); 复制数组元素
Arrays.equals(数组1，数组2);
Arrays.sort(数组)---->字面量类型数组 默认升序
数组元素排序
冒泡排序
交换次数比较多 效率最低
原理:将相邻的两个元素进行比较，最大的值放在右端。
N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。
int[] array = {10,20,6,12};
第一轮排序：
指针指向第一个元素10, 10与20比较 发现 20>10 不用交换 10,20,6,12
指针指向排序之后第2个元素 20 与 6比 20>6 交换位置 10,6,20,12
指针指向排序之后第3个元素 20 与 12 比 20>12 交换位置 10,6,12,20
第2轮排序：
指针指向第一个元素10 与6比 10>6 交换 6,10,12,20
指针指向第2个元素10 与12 10<12 不用交换 6,10,12,20
第3轮排序：
指针指向第一个元素6 与10比 不用交换 6,10,12,20
for(int i=1;i<array.length;i++){
for(int j=0,len = array.length;j<len-i;j++){
if(array[j]>array[j+1]){
//交换位置
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
选择排序
效率中等 交换次数减少
原理:从第一个元素开始，分别与后面的元素相比较，找到最小的元素与第一个元素交换位置；
从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；重复上述步骤，直到所有的元素都排成由小到大为止。
关键:
找最小元素
最小元素的索引位置
int[] array = {10,20,6,12};
第一轮排序：
指针指向第一个元素 10， 10先与20比 10<20 10在于6比较 10>6 最小值已经变成6了 6与12比较 6<12
找到了最小值 6 6与10进行位置的交换 6,20,10,12
第2轮排序：
指针指向第2个元素 20 20与10比 20>10 最小值变成10 10与12比较 10<12 最小值变成10
找到了最小值 10 与 20交换位置 6,10,20,12
第3轮排序：
指针指向第3个元素 20 与12比较 12<20 最小值变成12
找到了最小值 10 与 20交换位置 6,10,12,20
int len =array.length;
for(int i=0 ;i<len-1;i++){
//获得当前元素
//假设当前元素为最小值 min
int min = array[i];
int minIndex = i;
for(int j=i+1;j<len;j++){
if(min>arr[j]){
min = arr[j];
minIndex = j;
}
}
//交换位置
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
插入排序
将指针指向某个(第二个元素)元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，
遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止.
此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；
指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。
int[] array = {10,20,6,12};
第一轮排序：
指针指向第二个元素 20 左边元素都是有序的 先将20抽取抽来 10,__,6,12 20与10先比较 20>12 不交换 20填补空位 10,20,6,12
第二轮排序
指针指向第3个元素 6 将6抽取出来 10,20，,12
6先与20比较 20>6 20右移 10，_,20,12
6再与10比较 10>6 10右移 ___, 10,20,12
6填补空位 6,10,20,12
第3轮排序
指针指向第4个元素 12 将12抽取 6,10,20,___
12先与20比较 20>12 右移 6,10，___,20
12在与10进行比价 6,10，___,20
12与6比较 12>6 6,10，___,20
12填补空位 6,10，12,20
int len = array.length;
for(int i=1;i<len;i++)
int temp = array[i];
int leftIndex = i-1;
while(leftIndex>=0 && array[leftIndex]>temp){//左边元素比右边还要大
array[i] = array[leftIndex];
leftIndex--;
}
//当前元素填补空位
array[leftIndex+1] = temp;
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
