数组
数组定义
是一种数据结构，用于存放相同类型的数据集合。
- 其特点如下：
- 数组存放元素类型必需相同，不能有混合类型
- 数组个元素按先后顺序有序的存放在内存中，每个数组通过数组名和下标来访问
- 数组的长度固定，一旦创建，无法进行修改
- 数组元素类型可以是任意类型，包括基本类型和引用类型（类、接口、数组）
数组声明
定义了一个数组的名称、维数及数组元素的类型
//Java式写法（推荐）
int[] arr;
//C式写法
int []arr;
int arr[];
此时仅在栈内存分配空间，并没有实例化对象，因此栈内存并未使用。
数组的初始化
基本数据类型（数组元素为基本类型）的数组创建后，默认为其数组设置了初始值。
- 静态初始化
//除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组分配空间并赋值。
int[] arr = {23,46,85};
int[] arr = new int[]{23,46,85};
//注意：
//1.new int[3]{23,46,85}; --->错误
//2.int[] arr; --->错误
// arr = {23,46,85};
Boy[] b = {new Boy(18,180),new Boy(17,178)};
//引用类型数组，将Boy类型实例化对象初始化给b数组。
- 动态初始化
//数组定义与为数组元素分配空间并赋值的操作分开进行。
//先给数组分配空间，然后对各个元素赋值：
int[] arr;
arr = new int[3]
arr[0] = 23;
arr[1] = 46;
arr[2] = 85;
- 初始化默认值
//数组是类型，它的元素相当于类的实例变量，因此数组分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; //默认0
String[] name = new String[3]; //默认null
boolean[] chioce = new boolean[3]; //默认false
{% note warning flat %} 当数组类型为引用类型，默认为null，当访问其属性时，必需进行初始化，否则会报空指针异常。{% endnote %}
数组的访问
//获取数组的长度
int arr = new int[]{35,65,74};
int a = arr.length;
//通过下标访问数组元素
注意：数组的下标从0开始，最大到length-1
遍历数组元素
我们可以通过for循环实现对数组的遍历。
int arr = {53,67,98,36,78}
//遍历
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
数组的复制
//System.arraycopy方法实现数组复制
System.arraycop(src,srcPos,dest,destPos,length)
--src:源数组
--srcPos:源数组的起始位置
--dest:目标数组
--destPos:目标数组中的起始位置
--length:要复制的数组元素的数量
//Arrays.copyOf方法实现数组复制
数组的扩容
数组的长度在创建后是不可更改的。所谓扩容实际上是指创建一个更大的新数组并将原有数组的内容复制到其中。
//数组长度加一
int[] arr = Arrays.copyOf(arr,arr.length+1);
数组的添加
添加的逻辑：如果在数组的第i个位置添加数值，在自i开始，所有值向后移动一位，腾出原有的位置i，再向其添加数值。
public static void main(String[] args){
//功能：给定一个数组，在数组下标为2的位置上添加一个元素91
//1.给定一个数组；
int[] arr = {62,57,35,76,25,86};
//2.输出增加元素前的数组；
System.out.print("增加元素前的数组：");
for(int i=0; i<arr.length-1; i++){
if(i != arr.length-1){
System.out.print(arr[i]+",");
}else{//i == arr.length-1 最后一个元素不用加逗号
System.out.print(arr[i]);
}
}
//3.添加元素；
// arr[5]=arr[4]; //基本方法
// arr[4]=arr[3];
// arr[3]=arr[2];
// arr[2]=91;
int index = 2; //数组中添加的位置
for(int i = arr.length-1; i>=(index+1); i++){
arr[i]=arr[i-1];
}
arr[index] = 91; //数组中要添加的元素
//4.输出增加元素后的数组；
System.out.print("\n增加元素后的数组：");
for(int i=0; i<arr.length-1; i++){
if(i != arr.length-1){
System.out.print(arr[i]+",");
}else{//i == arr.length-1 最后一个元素不用加逗号
System.out.print(arr[i]);
}
}
}
- 提取一个添加元素的方法
//在数组的确定位置上添加一个元素
//不确定因素：形参，哪个数组，哪个位置，哪个元素
import java.util.Scanner;
public static void main(String[] args){
int[] arr = {62,57,35,76,25,86）;
//从键盘接收数据
Scanner sc = new System(System.in); //引用类型 引用类型变量 = 创建 构造方法
System.out.println("请录入你要添加元素的指定下标：");
int index = sc.nextInt();
System.out.println("请录入你要添加的元素：");
int ele = sc.nextInt();
//3.增加元素
//调用方法
intsertEle(arr, index, ele);
//4.输出增加元素后的数组；
System.out.print("\n增加元素后的数组：")；
for(int i=0, i<arr.length-1, i++){
if(i != arr.length-1){
System.out.print(arr[i]+",");
}else{//i == arr.length-1 最后一个元素不用加逗号
System.out.print(arr[i]);
}
}
}
public static void insertEle(int[] arr, int index, int ele){
for(int i = arr.length-1; i>=(index+1); i++){
arr[i]=arr[i-1];
}
arr[index] = ele ；
}
数组的删除
- 删除指定位置的元素
import java.util.Arrays;
public static void main(String[] args){
//功能：给定一个数组，删除下标为2元素
//1.定义一个数组；
int[] arr = {62,57,35,76,25,86};
//2.输出删除前的数组；
System.out.println("删除前的数组："+Arrays.toString(arr));
//3.删除
int index = 0;
for(int i=index; i<arr.length-2; i++) {
arr[i] = arr[i+1];
}
arr[arr.length-1] = 0;
//4.输出删除后的数组；
System.out.println("删除后的数组："+Arrays.toString(arr));
}
- 删除指定的元素
import java.util.Arrays;
public static void main(String[] args){
//功能：给定一个数组，删除元素25
//1.定义一个数组；
int[] arr = {62,57,35,76,25,86};
//2.输出删除前的数组；
System.out.println("删除前的数组："+Arrays.toString(arr));
//找到要删除的元素对应的索引即可：
int index = -1;
for(int i=0; i<arr.length; i++) {
if(arr[i] == 25) {
index = i;
break;
}
}
//3.删除
if(index != -1) { //数组过滤
for(int i=index; i<=arr.length-2; i++) {
arr[i] = arr[i+1];
}
arr[arr.length-1] = 0;
}else { //index=-1
System.out.println("没有你要删除的元素");
}
//4.输出删除后的数组；
System.out.println("删除后的数组："+Arrays.toString(arr));
}
数组的排序
-
冒泡排序
比较相邻的元素，如果违反指定的顺序准则(升序或降序),则交换位置。可以简化的理解，第一次找到所有元素中最大(最小)的放在最后一个位置上，不再变动；第二次找到剩余元素中最大(最小)放到倒数第二位不再变动，以此类推。
int[] arr = {46,86,37,77,36,79,38,58,74}
//代码式
for(int i=0; i<arr.length-1; i++){ //遍历轮数
for(int j=0; j<arr.length-1-i; i++){ //遍历次数
if(arr[1] > arr[a+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
aee[j+1] = tmp;
}
}
}
//方法式
Arrays.sort()方法
方法
//五要素
public static //修饰符（静态）
void //返回值类型
abc //方法名
(int c, int a) //参数列表
{...} //方法体
数组的查询
- 查询指定位置的元素
public static void main(String[] args){
//找出索引对应的元素
int[] arr = (62,57,35,76,25,37);
System.out.println(arr[2]);
}
- 查询指定元素的位置
public static void main(String[] args){
//找出元素对应的索引
int[] arr = {62,57,35,76,25,35};//重复元素
int index = -1; //这个初始值只要不是数组的索引即可
for(int i=0; i<arr.length; i++){
if(arr[i]==35){
index = i;//只要找到了这个元素，那么index就变成
break;//只要找到这个元素，循环就停止
}
}
if（index != -1）{
System.out.println("元素对应的索引为："+index);
}else{//index == -1
System.out.println("查无次数！");
}
}
- 将查询功能提取为一个方法
public static void main(String[] args){
//找出元素对应的索引
int[] arr = {62,57,35,76,25,35};//重复元素
//调用方法
int index = getIndex(arr,57)
//后续对index的值进行判断
if（index != -1）{
System.out.println("元素对应的索引为："+index);
}else{
System.out.println("查无次数！");
}
public static int getIndex(int[],int ele){
int index = -1;
for(int i=0; i<arr.length; i++){
if(arr[i]==else){
index = i;
break;
}
}
return index;
}
main方法的解释
默认情况下，虚拟机是在调用main方法的时候传入了一个长度为0的数组。
public static void main(String[] args){
System.out.println(args.length);
for(String str : args){
System.out.println(str);
}
}
可变参数
提供了一个方法，参数的个数是可变的
作用：解决了部分的重载问题
//1.方法的内部对可变参数的处理跟数组一样。
//2.可变数据和其他数据一起作为形参的时候，可变参数一定要放在最后。
//例如（int num1,int...num2）,这样传递值时，其他参数才能接收到数据。
public static void main(String[] args){
System.out.println(args.length);
for(String str : args){
System.out.println(str);
}
}
//
public static void Demo(int...num ) { //int...num为可变参数
System.out.println("---------");
for(int i:num) { //使用增强for循环遍历数组
System.out.println(i+"\t");
}
System.out.println(); //换行
}
增强for循环 VS 普通for循环
- 增强for循环和普通for循环的区别
- 增强for循环必须有被遍历的目标（如集合或数组）。
- 普通for循环遍历数组的时候需要索引。
- 增强for循环不能获取下标，所以遍历数组时最好使用普通for循环。
- 普通数组中使用
// 增强for循环
for (int item : array) {
System.out.println(item);
}
// 普通for循环
for (int i = 0; i < array.length; i++)
System.out.println(array[i]);
- 二维数组中的使用
// 增强for循环
for (int arr[] : array2) {
for (int item : arr) {
System.out.println(item);
}
}
// 普通for循环
for (int i = 0; i < array2.length; i++) {
for (int j = 0; j < array2[i].length; j++) {
System.out.println(array2[i][j]);
}
}
- List中的使用
// 增强for循环
for (String item : list){
System.out.println(item);
}
//普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
程序
输出两个int数中的最大值
用户从控制台接收两个整数，通过程序找出两个数中的最大值。控制台的交互效果如图所示。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数：a，b（以空格隔开）");
int a = sc.nextInt();
int b = sc.nextInt();
if(a>b){
System.out.println("最大值为"+a);
}
else {
System.out.println("最大值为"+b);
}
编写三个数值的排序程序
使用程序为用户所录入的 3 个数值进行升序排列，并将排序后的结果输出到控制台。程序交互过程如图所示：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入三个整数：a，b，c（以空格隔开）");
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
System.out.println("您输入的是：\n"+"a="+a+",b="+b+",c="+c);
if(a<b) {
if(b<c) {System.out.println("升序排序后，结果为："+'\r'+"c="+a+",b="+b+",a="+c);}
else {
if(a<c) {System.out.println("升序排序后，结果为："+'\r'+"c="+a+",b="+c+",a="+b);
}else {System.out.println("升序排序后，结果为："+'\r'+"c="+c+",b="+a+",a="+b);}
}
}
else {
if(b<c) {
if(a<c) {System.out.println("升序排序后，结果为："+'\r'+"c="+b+",b="+a+",a="+c);}
else {System.out.println("升序排序后，结果为："+'\r'+"c="+b+",b="+c+",a="+a);}
}else {System.out.println("升序排序后，结果为："+'\r'+"c="+c+",b="+b+",a="+a);}
}
}
编写程序判断某一个年份是否为闰年
本案例需要使用交互的方式判断某年是否为闰年：用户从控制台输入需要判断的年份值，由程序使用if-else判断该年是否为闰年，并将判断结果输出到控制台。程序交互过程如图所示：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份（例如2012）");
int a = sc.nextInt();
if (a%4==0 && a%100!=0 || a%400==0) {
System.out.println(a+"是闰年");
}else{System.out.println(a+"是平年");}
}
数列求和
有数列为：9，99，999，…，9999999999。要求使用程序计算此数列的和，并在控制台输出结果。交互效果如图所示。
public static void main(String[] args) {
long a = 0;
long sum = 0;
for(int i=1; i<=10; i++) {
a = a*10 + 9;
sum += a;
}
System.out.println("9+99+999+...+9999999999="+sum);
}
查询数组最小值，并将数组扩容形成新数组
创建程序，实现查询数组中最小值的功能，并将最小值放入数组的第一位。需求为：创建一个长度为 10 的数组，数组内放置 10 个 0 到 99 之间（包含0，包含99）的随机整数作为数组元素，要求查询出数组中的最小值，并打印显示在界面上。然后，将数组的长度扩容为 11，将查询到的数组最小值记载为数组的第一个元素，并打印扩容后的数组的内容。界面效果如图所示：
public static void main(String[] args) {
int[] a = {47,66,27,74,24,85,46,97,45,39};
System.out.println("数组中的数据为：[47,66,27,74,24,85,46,97,45,39]");
//筛选最小值
int min = a[0];
for(int i:a) {
if(i<min) {
min = i;
}
}
// Arrays.sort(a);
// System.out.println("最小值是："+a[0]);
System.out.println("最小值是："+min);
//利用Arrays.copyOf扩容，将长度加一的数组替换为新数组
int[] a2 = Arrays.copyOf(a,a.length+1);
int[] a3 = new int[11];
a3[0] = min;
System.arraycopy(a,0, a3,1, 10);
for(int i=0;i<a3.length;i++){
System.out.println(a3[i]);
}
System.out.println("数组中的数据为：[24，47,66,27,74,24,85,46,97,45,39]");
}
❤️ END ❤️
扫一扫
817
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
