Java
day4-5——2023.8.8-2023.8.9
数组
定义
数组其实也是声明的一个变量，即普通的变量不同的是，可以存储相同数据类型的一组数据
数组是一个长度固定的数据结构，数组也是一个对象（引用数据类型）
数组的声明方式
语法
步骤1：先声明数组
1，数据类型 变量名[];
2，数据类型[] 变量
步骤2：给数组声明空间
数组名 = new 数组数据类型[数组长度]；
实例：
int array;
array = new int[10];
合并写法：int[] array = new int[10]
步骤3：给数组的空间赋值，分配空间
package com.iweb.airui369.day04.Array;
public class ArrayTest01 {
//数组的声明
public static void main(String[] args) {
//数组声明
//写法1
int[] arr = new int[5];
//给数组空间赋值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;
//写法2：已知数组的内容。可以简写
int[] arr1 = new int[]{10,20,30,40,50};
//写法三：再简写
int[] arr2 = {10,20,30,40,50};
//使用写法一，声明一个string类型的数组，数组中有5个空间，内容随意
String[] arr3 = new String[5];
arr3[0] = "10";
arr3[1] = "20";
arr3[2] = "30";
arr3[3] = "40";
arr3[4] = "50";
//使用写法三，声明一个char类型的数组，数组有5个char类型的值
char[] arr4 = {'1','2','3','4','5'};
for (int i = 0; i < 5; i++) {
System.out.println(arr[i]);
}
}
}
数组的特征(长度、索引)
长度固定，索引下标从0开始 ，下标的值是 从 0 ~ 长度-1
数组的遍历(循环进行遍历)
package com.iweb.airui369.day04.Array;
public class ArrayTest02 {
public static void main(String[] args) {
int[] arr = {10,20,30,40,50};
//直接输出数组，输出的是数组变量的引用地址
System.out.println(arr);
//通过数组下标，将它的值输出
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("------------------------");
//使用for循环遍历
//循环的次数 ： 跟数组的长度一致
for (int i = 0; i < 5; i++) {
System.out.println(arr[i]);
}
System.out.println("------------------------");
//数组中，有一个length属性，可以返回数组的长度
System.out.println(arr.length); //5
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
循环录入5个学生的成绩到数组中
录完之后，将5个人的成绩输出，并输出其中的最高分
public class Demo03 {
public static void main(String[] args) {
//int[] arr = {11,22,33,44,55};
通过Demo02调用输出方法
//Demo02.printArray(arr);
//循环录入5个学生的成绩到数组中
//录完之后，将5个人的成绩输出，并输出其中的最高分
//1，数组长度 5
//2，循环录入
//3，找到最高分
//创建长度为5的数组
int[] arr = new int[5];
//创建输入对象scanner
Scanner scanner = new Scanner(System.in);
//定义一个最大值变量
int max = 0;
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第" + (i+1) + "个学生的成绩:");
//通过数组下标，获取输入的值
arr[i] = scanner.nextInt();
//将每次输入的值和max做比较，保留大的值
max = max > arr[i] ? max : arr[i];
}
System.out.println("五位学生的成绩是:");
Demo02.printArray(arr);
System.out.println("最高分是:" + max);
}
}
数组的内存分配
1，int[] arr = new int[5] : 表示在内存的堆区申请一个空间，这个空间有5个位置，每个位置的默认值是0，然后将这个区域在内存中的地址，指向变量 arr
2,arr[0] = 10 ; 表示通过 arr对应的地址引用，找到内存中数组的位置空间，通过下标0，找到这个空间中对应下标的值，然后将10 替换掉原有的默认值
二维数组的创建和遍历
二维数组指的是，在数组中，继续存放数组的一种形式
public class Demo05 {
public static void main(String[] args) {
//创建二维数组
//创建格式 ：
//格式1：
//数据类型[][] 数组名 = new 数据类型[m][n]
//格式2:
// 数据类型[][] 数组名 = {{...},{...},{...}};
//
// 有个5个班级，各有5个学生数学课成绩
//将所有班级，所有学生的数学成绩录入，
//录入后，求5个班各自的总成绩
Scanner scanner = new Scanner(System.in);
//定义数组
int[][] array = new int[5][5];
//使用嵌套for循环完成成绩的录入
//i 班级 j 学生
for (int i = 0; i < 5; i++) {
System.out.println("第" + (i+1) + "个班:");
for (int j = 0; j < 5; j++) {
System.out.println("第" + (j+1) + "个学生的成绩:");
array[i][j] = scanner.nextInt();
}
}
//统计成绩：
for (int i = 0; i < array.length; i++) {
int total = 0; //记录总成绩
for (int j = 0; j < array[i].length; j++) {
//拿到每个班的学生的成绩做累加
total += array[i][j];
}
System.out.println("第" + (i+1) + "个班级的总成绩是:" + total);
}
}
}
基本算法了解
排序方法
冒泡
● 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
● 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
● 针对所有的元素重复以上的步骤，除了最后一个；
● 重复步骤1~3，直到排序完成
/*
冒泡排序
*/
public class BubbleSort {
public static void main(String[] args) {
//声明一个数组，
//排序是为了将数组中的数据按照顺序从小到大排列
int[] arr = {25,36,11,5,2};
System.out.println("排序前");
printArray(arr);
/* //第一次排序
for (int i = 0; i < arr.length - 1; i++) {
//将数组的值做两两比较
if (arr[i] > arr[i+1]){
//交换
int temp= arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第一次排序完:");
printArray(arr);
//第二次排序 25 11 5 2 36
for (int i = 0; i < arr.length-1-1 ; i++) {
//将数组的值做两两比较
if (arr[i] > arr[i+1]){
//交换
int temp= arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第二次排序完:");
printArray(arr);
//第三次排序
for (int i = 0; i < arr.length-1-1-1 ; i++) {
//将数组的值做两两比较
if (arr[i] > arr[i+1]){
//交换
int temp= arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第三次排序完:");
printArray(arr);
//第四次排序
for (int i = 0; i < arr.length-1-1-1-1 ; i++) {
//将数组的值做两两比较
if (arr[i] > arr[i+1]){
//交换
int temp= arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println("第四次排序完:");
printArray(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;
}
}
}*/
bubbleSort(arr);
System.out.println("排序完:");
printArray(arr);
}
//定义一个冒泡排序的方法：
public static void bubbleSort(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;
}
}
}
}
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
选择
n条数据，经过n-1趟排序，得到有序结果
● 开始排序之前，划分一个有序区域，和无序区域
● 第一次排序开始的时候， 从无序区一个个去寻找最小值，每次找到小的值就做标记，所有数据找完之后，
找到了无序区最小的值，把它移动最前面，作为有序区
● 继续在无序区找小的值，每一轮都找到一个无序区的最小值，把这个值，依次往有序区的后面排放（
其实是将最小值的位置，和有序区的后一个位置的值做交换）
● 重复以上第3步
//选择排序
public class SelectSort {
public static void main(String[] args) {
int[] arr = {33,12,4,56,23,44,74,3};
System.out.println("排序前:");
printArray(arr);
selectSort(arr);
System.out.println("排序完:");
printArray(arr);
}
//输出方法
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
//写一个选择排序方法
public static void selectSort(int[] arr){
//存在一个有序区和无序区
//排序开始之前，有序区没有内容
//第一次排序的时候，将第一个数值标记为有序的第一个值
for (int i = 0; i < arr.length - 1; i++) {
//指定一个最小数值的索引
int minIndex = i;
//从有序区的后面的第一个(i+1)开始遍历
for (int j = i+1; j < arr.length ; j++) {
//找到最小的值
if (arr[j] < arr[minIndex]){
//将最小值的下标做交换
minIndex = j;
}
}
//循环之后，做数据交换
if (i != minIndex){
int temp = arr[i] ;
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
}
插入
● 从第一个元素开始，该元素可以认为已经被排序；
● 取出下一个元素，在已经排序的元素序列中从后向前扫描；
● 如果该元素（已排序）大于新元素，将该元素移到下一位置；
● 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
● 将新元素插入到该位置后；
● 重复步骤2~5
public class InsertSort {
public static void main(String[] args) {
int[] arr = {33,12,4,56,23,44,74,3};
System.out.println("排序前:");
printArray(arr);
//排序
insertSort(arr);
System.out.println("排序完:");
printArray(arr);
}
//输出方法
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
//插入排序方法
public static void insertSort(int[] arr){
//第一次循环从第二个元素开始，默认第一个元素是有序的
for (int i = 1; i < arr.length; i++) {
//指定一个插入数
int insertNum = arr[i];
//指定一个已经排序好的元素的个数
int j = i - 1;
//循环判断
//如果插入的值，小于前面的有序区的最后一个值(arr[j])，
//把有序区的最后一个值往后移动，
//然后再和最后一个值前面的值（arr[j-1]）作比较，所以，
//循环的时候，需要做j-- 操作
while ( j >= 0 && arr[j] > insertNum){
arr[j+1] = arr[j];
j--;
}
arr[j+1] = insertNum;
}
}
}
快排
public class QuickSort {
//写一个快速排序的方法
public static void quickSort(int[] arr,int left , int right){
//提前声明需要使用的变量
int i,j,temp,t;
//递归结束条件
if (left > right){
return;
}
//开始排序
i = left;
j = right;
temp = arr[left]; //中间值
//循环判断
while (i < j){
//如果j下标的值，比中间值大，j做--操作
while (temp <= arr[j] && i < j){
j--;
}
//如果i下标的值，比中间值小，i做++操作
while (temp >= arr[i] && i < j){
i++;
}
//如果上面两个条件不满足，i 和 j 交换
if(i < j){
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后需要将中间值和 j的值做交换
arr[left] = arr[j];
arr[j] = temp;
//递归调用左边
quickSort(arr,left,j-1);
//递归调用右边
quickSort(arr,j+1,right);
}
//输出方法
public static void printArray(int[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr = {10,31,43,2,34,12,4};
System.out.println("排序前");
printArray(arr);
//调用排序方法
quickSort(arr,0,arr.length-1);
System.out.println("排序后");
printArray(arr);
}
}
冒泡排序 10w排序时间：16613
选择排序 10w排序时间：4683
插入排序 10w排序时间：1211
快速排序 10w排序时间：19
查找算法
查找 ：指的是在指定数组中，查找指定值，返回其下标的一种方式
public class SearchDemo {
public static void main(String[] args) {
//定义一个数组
int[] arr = {12,34,56,23,11,66,39,36};
//查找39在数组中的什么位置？返回它的下标
//基本查找方式:
int index = -1;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 39){
index = i;
break;
}
}
System.out.println("查找的39的下标:" + index);
}
}
二分查找法
也称为折半查找法，用来查找有序的序列数据
/*
二分查找
*/
public class BinarySearch {
public static void main(String[] args) {
//定义一个有序的数组
int[] arr = {11,22,33,44,55,66,77,88,99};
int index = getIndex(arr, 44);
System.out.println("44的下标是:" + index);
}
//写一个二分查找方法,返回值是 索引值
//参数是 数组和 要查找的值
public static int getIndex(int[] arr,int value){
//定义最小索引、最大索引
int max = arr.length -1 ;
int min = 0;
//计算中间索引
int mid = (max + min) / 2;
//拿查找的值和中间索引值做比较
//如果中间值和查找的值不同，就循环，相同，循环结束
while (value != arr[mid]){
//中间值大 ，往左找
if (arr[mid] > value){
max = mid - 1;
//中间值小,往右找
}else if (arr[mid] < value){
min = mid + 1;
}
//判断,没有找到的情况
if (min > max){
return -1;
}
mid = (max + min) / 2;
}
return mid;
}
}
数组中，存放了10位同学的平均成绩，其中张三的成绩是84分，其他人的平均成绩在70-100之间随机生成
求：生成成绩后，张三的成绩在班级中的排名是多少
public class Demo01 {
public static void main(String[] args) {
/*
数组中，存放了10位同学的平均成绩，其中张三的成绩是84分，
其他人的平均成绩在70-100之间随机生成
求：生成成绩后，张三的成绩在班级中的排名是多少
*/
//随机生成数组数据
int[] arr = new int[10];
arr[0] = 84;
//创建随机数对象random
Random random = new Random();
for (int i = 1; i < arr.length; i++) {
arr[i] = random.nextInt(30) + 70;
}
System.out.println("所有学生的平均成绩:");
BubbleSort.printArray(arr);
//数组排序
BubbleSort.bubbleSort(arr);
//数组查找
int index = BinarySearch.getIndex(arr, 84);
int paiming = arr.length - index;
System.out.println("张三的排名是:" + paiming);
}
}
Arrays工具类
jdk提供给我们使用的一个工具类，工具类中一般都封装了 很多的方法，可以给我们使用
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = {10,33,4,21,35,6};
//toString()方法， 将数组以字符串形式输出
System.out.println(Arrays.toString(arr));
Arrays.sort(arr); //调用排序方法
System.out.println(Arrays.toString(arr));
int i = Arrays.binarySearch(arr, 33); //搜索
System.out.println(i);
//复制数组
int[] arr01 = Arrays.copyOf(arr, 10);
System.out.println(Arrays.toString(arr01));
char[] charArray = {'a','c','b','x','f'};
Arrays.sort(charArray);
System.out.println(Arrays.toString(charArray));
}
}
9650
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
