Java从入门到实战总结-1.4、Java数组
文章目录
1、数组
（1）、概述
数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
（2）、创建格式
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 3. 数据类型[] 数组名; 格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};
（3）、下标
可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。
例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
（4）、数组长度获取
数组名称.length
（5）、注意
使用数组不当， 会出现如下问题：
-
数组未赋值： 空指针异常
-
超出长度的下标操作： 数组越界异常
-
注意：数组的长度在创建时就固定了。
2、不常用数组定义格式
package day4;
public class Demo1 {
public static void main(String[] args) {
//数组不常用的创建方式
//1、创建数组，不初始化
int[] nums;
//2、创建数组，并制定数组中的内容
int[] ages = new int[] {10, 11, 12, 13, 14};
}
}
3、数组常见问题
1、数组下标越界问题，下标是从0开始计算的，下标最大值比数组长度要小1，比如长度是5，则下标是从0到4
2、空指针问题，当创建数组没有进行初始化时直接调用数组就会造成空指针问题
4、最大值最小值
利用中间变量存储后挨个比对确认即可
package day4;
public class Demo2 {
public static void main(String[] args) {
int[] nums = {10, 30 ,40, 33, 22, 20, 11, 13};
int max = nums[0],min = nums[0];
for(int i = 0; i < nums.length; i++) {
// max = max > nums[i] ? max:nums[i];
if(max < nums[i]) {
max = nums[i];
}
// min = min < nums[i] ? min:nums[i];
if(min > nums[i]) {
min = nums[i];
}
}
System.out.println("数组最大值："+max+"，最小值："+min);
}
}
5、冒泡排序
（1）、原理
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
（2）、名字由来
是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），就如同水中的气泡最终会上浮到顶端一样，故名“冒泡排序”。
（3）、升序排列的口诀
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
（4）、降序排序的口诀
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1
关键总结（和之前打印直角三角形有类似之处）：
- 外层循环控制轮数（行数）
- 内层循环控制每轮次数（列数）
package day4;
import java.util.Arrays;
public class Demo3 {
public static void main(String[] args) {
//冒泡排序,升序，大的值在右（降序比较判断时相反即可，大的值在左边）
int[] nums = {1, 2, 3, 6, 5, 4, 9, 8, 7};
for(int i = 0; i < nums.length - 1; i++) {
for(int j = 0; j < nums.length - 1 - i; j++) {
if(nums[j] > nums[j + 1]) {
int tmp = nums[j];
nums[j] = nums[j+1];
nums[j + 1] = tmp;
}
}
}
System.out.println(Arrays.toString(nums));
}
}
6、二分查找
（1）、概述
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。
（2）、原理
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功，直到子数组不存在为止，表示查找不成功。
package day4;
import java.util.Arrays;
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
//二分查找，查找的数据必须有序排列的顺序结构
int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
System.out.println("要搜索的数组："+Arrays.toString(nums));
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要在数组nums中查找的数据：");
int searchNum = scanner.nextInt();
//1、定义最小下标、最大下标、中间下标
int minIndex = 0;
int maxIndex = nums.length - 1;
int centerIndex = (minIndex + maxIndex)/2;
int i = 1;
while(true) {
System.out.println("查找次数："+i);
//2、当中间值大于搜索值，说明要搜索值在左边，则最大下标更新中间下标减-1
//当中间值小于搜索值，则说明要搜索值在右边，最小值下标更新为中间下标+1
//相等时说明找到了直接退出搜索
if(nums[centerIndex] > searchNum) {
maxIndex = centerIndex - 1;
} else if(nums[centerIndex] < searchNum) {
minIndex = centerIndex + 1;
} else {
break;
}
//出现特殊情况一直搜索不到
if(minIndex > maxIndex) {
centerIndex = -1;
break;
}
//3、搜索一轮后根据最大和最小下标的更新再更新中间下标
centerIndex = (minIndex+maxIndex)/2;
i++;
}
System.out.println("要搜索的数据在数组中的位置："+centerIndex);
}
}
7、多维数组(了解)
可以简单理解为数组嵌套，每个数组指向的内容也是数组
创建格式：
数据类型 数组名 = new 数据类型[长度]
//int[][] 二维数组名称 = new int[外层数组长度][内层数组长度];
package day4;
public class Demo5 {
public static void main(String[] args) {
int[][] nums = new int[10][];
nums[0] = new int[] {1, 2, 3};
System.out.println(nums[0][2]);
}
}
8、代码练习
1、今天同学们相约一起爬山游玩，为了更好的进行这场活动，大家准备推举 一个人作为出游的临时队长。为了体现合理公平，大家提出了一个比较有趣的规则。所有人围成一圈，顺序排号。从第一个人开始报数（从 1 到 3 报数）， 凡报到 3 的人退出圈子，剩下的人继续报数，最后留下的当选为队长。 请你通过编写程序，求出一组人中的队长是原来第几位同学。
package day4;
import java.util.Scanner;
public class Homework10101006 {
public static void main(String[] args) {
//获取参与的同学人数
System.out.println("请输入参与人数：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
//将参与的同学编进一个布尔数组，全部赋值为true
boolean[] num = new boolean[n];
for (int i = 0; i < num.length; i++) {
num[i] = true;
}
int leftNum = n; // 剩余人数
int i = 0; // 报数
int index = 0; // 计数
//当剩余人数大于1时，循环报数，报到3的赋值为false，退出报数
while (leftNum > 1) {
if (num[index] == true) {
i++; // 开始报数
if (i == 3) {
num[index] = false;
i = 0; // 重新报数
leftNum--; // 剩余人数减一
}
}
index++;
if (index == n) {
index = 0;
}
}
//剩余为true的同学当选队长
for (int j = 0; j < num.length; j++) {
if (num[j] == true) {
System.out.println("第" + (j + 1) + "位同学是队长");
}
}
}
}
2、逻辑及流程控制
1、查找某个整数
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。 然后将输
入一个整数，查找此整数，找到输出下标， 没找到给出提示。
2、找出数组的最值
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。输出数组
的最大值、最小值。
3、两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为
目标值的那两个整数，并输出他们的数组下标
假设每种输入只会对应一个答案，不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以输出 0，1
4、排序并查找
对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找 6 并
输出排序后的下标。
5、移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保
持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12] 输出: [1,3,12,0,0]
package day4;
import java.util.Arrays;
import java.util.Scanner;
public class Homework10101007 {
/**
* 1、查找某个整数
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。 然后将输
入一个整数，查找此整数，找到输出下标， 没找到给出提示。
2、找出数组的最值
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。输出数组
的最大值、最小值。
3、两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为
目标值的那两个整数，并输出他们的数组下标
假设每种输入只会对应一个答案，不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以输出 0，1
4、排序并查找
对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找 6 并
输出排序后的下标。
5、移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保
持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12] 输出: [1,3,12,0,0]
*/
public static void main(String[] args) {
//1、查找某个整数
findIntNum();
//2、找到数组的最值
findMaxMin();
//3、两数之和
System.out.println("两数之和：");
int[] nums = new int[] {2, 7, 11, 15};
int target = 9;
System.out.println(Arrays.toString(twoSum(nums, target)));
//4、排序并查找
System.out.println("对特定数组的排序后查找到序号为："+sortFindIndex());
//5、移动零
int[] nums2 = new int[]{0,1,0,3,12};
System.out.println("移动零前的数组"+Arrays.toString(nums2));
moveZeroes(nums2);
System.out.println("移动零并排序后的数组"+Arrays.toString(nums2));
}
/**
* 冒泡排序，升序
*/
public static void sort(int[] nums) {
//排序
for(int i = 0; i < nums.length - 1; i++) {
for(int j = 0; j < nums.length - 1 - i; j++) {
if(nums[j] > nums[j + 1]) {
int tmp = nums[j];
nums[j] = nums[j+1];
nums[j + 1] = tmp;
}
}
}
}
/**
* 二分查找
* 返回值：未找到返回-1，找到返回对应数组中的序号
*/
public static int midSearch(int[] nums, int searchNum) {
int minIndex = 0;
int maxIndex = nums.length - 1;
int centerIndex = (minIndex + maxIndex)/2;
int i = 1;
while(true) {
if(nums[centerIndex] > searchNum) {
maxIndex = centerIndex - 1;
} else if(nums[centerIndex] < searchNum) {
minIndex = centerIndex + 1;
} else {
break;
}
if(minIndex > maxIndex) {
centerIndex = -1;
break;
}
centerIndex = (minIndex+maxIndex)/2;
i++;
}
return centerIndex;
}
/**
* 1、查找某个整数
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。 然后将输
入一个整数，查找此整数，找到输出下标， 没找到给出提示。
*/
public static void findIntNum() {
int[] nums = new int[10];
Scanner scanner = new Scanner(System.in);
System.out.println("请连续输入10个数用于查找：");
for(int i = 0; i < 10; i++) {
nums[i] = scanner.nextInt();
}
sort(nums);
System.out.println("请输入要在数组nums中查找的数据：");
int searchNum = scanner.nextInt();
int res = midSearch(nums, searchNum);
if(res == -1) {
System.out.println("未找到要搜索的值");
return ;
}
System.out.println("要搜索的数据在数组中的位置："+res);
}
/**
*2、找出数组的最值
定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。输出数组
的最大值、最小值。
*/
public static void findMaxMin() {
int[] nums = new int[10];
Scanner scanner = new Scanner(System.in);
System.out.println("请连续输入10个整数组成数组：");
for(int i = 0; i < 10; i++) {
nums[i] = scanner.nextInt();
}
int max = nums[0],min = nums[0];
for(int i = 0; i < nums.length; i++) {
if(max < nums[i]) {
max = nums[i];
}
if(min > nums[i]) {
min = nums[i];
}
}
System.out.println("数组最大值："+max+"，最小值："+min);
}
/**
* 3、两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为
目标值的那两个整数，并输出他们的数组下标
假设每种输入只会对应一个答案，不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以输出 0，1
*/
public static int[] twoSum(int[] nums, int target) {
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[j] == target - nums[i]) {
return new int[] {i, j};
}
}
}
return new int[]{0,0};
}
/**
* 4、排序并查找
对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找 6 并
输出排序后的下标。
*/
public static int sortFindIndex() {
int[] nums = new int[]{1, 3, 9, 5, 6, 7, 15, 4, 8};
sort(nums);
return midSearch(nums, 6);
}
/**
* 5、移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保
持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12] 输出: [1,3,12,0,0]
*/
public static void moveZeroes(int[] nums) {
int curIndex = nums.length - 1;
int lastIndex = nums.length - 1;
int count = 0;
while(curIndex >= 0) {
if (nums[curIndex] == 0) {
count = lastIndex - curIndex;
for (int i = 0; i < count; i++) {
nums[curIndex + i] = nums[curIndex + i + 1];
}
nums[lastIndex] = 0;
lastIndex--;
}
curIndex--;
}
}
}
1632
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
