数组是一种数据结构，用来存储同一类型值的集合，通过一个整型下标可以访问数组中的每一个值
如果a是一个整型数组，a
目录
创建一个数组
int[] a =new int[10];
这条语句创建了一个可以存储10个整数的数组
//有三种方法可以声明一个数组
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};
给数组元素赋值
int[] a =new int[10];
for(int i=0;i<10;i++){
a[i]=i;
}
//这里也可以用i < a.length代替i < 10
创建一个数字数组时，所有元素都初始化为0。boolean数组的元素会初始化为false。表示这些元素还没有存放任何对象。
打印一个数组
//单行代码直接打印
package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo2 {
public static void main(String[] args) {
int[] i = {1,2,3,4,5};
String s = Arrays.toString(i);
System.out.println(i); //打印数组的地址值
System.out.println(s); //打印数组元素值
//System.out.println(Arrays.toString(i))；
}
}
结果为
//循环打印
int[] aa = {1,2,3};
for(int i=0;i<aa.length;i++){
System.out.println(aa[i]);
}
结果为
for each循环
int[] arr ={0,1,2,3,4};
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int a1:arr){
System.out.println(a1);
}
这两个循环的结果是一样的，都是打印从0到4的数值
数组复制（复制地址）
在Java中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量将引用同一个数组
package test;
public class ArrayDemo1 {
public static void main(String[] args) {
//定义第二个数组的时候把第一个数组的地址赋值给第二个数组
int[] arr1 = new int[2];
int[] arr2 = arr1;
//对arr1进行赋值并打印
arr1[0] = 1;
arr1[1] = 2;
System.out.println(arr1[0]+" "+arr1[1]);
//修改arr2[0]中的值为3，打印arr1和arr2
arr2[0] = 3;
System.out.println(arr1[0]+" "+arr1[1]);
System.out.println(arr2[0]+" "+arr2[1]);
}
}
结果为
可以发现，arr1和arr2指向的是同一个地址，所以修改arr2中的值，
arr1中的值也会被改变
数组复制（复制值）
如果希望将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类的copyOf()方法与copyOfRange()方法
copyOf()方法是复制旧数组里面的值到指定长度的新数组中。
copyOfRange()方法是将指定数组的指定长度复制到一个新数组中。
1、copyOf()方法 —— copyOf(arr,int newlength)
package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = {1,2,3};
//旧数组arr中的值被复制到了指定长度为5的新数组中
int[] new_arr = Arrays.copyOf(arr,5);
for(int i : new_arr){
System.out.println(i);
}
}
}
/*
如果数组元素是数值型，那么多余的元素将被赋值为0；如果数组元素是布尔型，则将赋值为false。
相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
*/
结果为
其实像下面这样输出更好看一些
System.out.println(Arrays.toString(new_arr));
2、copyOfRange()方法 —— copyOfRange(arr, int start, int stop); 后面两个参数定义从旧数组中截取从哪到哪的数值
package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = {1,2,3};
int[] new_arr = Arrays.copyOfRange(arr,0,2);
System.out.println(Arrays.toString(new_arr));
}
}
结果为
数组元素查找(查找指定元素第一次在数组中出现的索引)
package test1;
import java.util.Scanner;
public class ArrayDemo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int input = sc.nextInt();
int[] a = {12,34,25,31,15};
for(int i=0;i<a.length;i++){
if(a[i]==input){
System.out.println("索引是"+i);
break;
}
if(i==a.length-1 && a[i]!=input){
System.out.println("not found!");
}
}
}
}
结果为
反转数组
//方法一
package test.ArrayDemo;
import java.util.Arrays;
public class ArrayDemo2 {
public static void main(String[] args) {
int[] i = {1,2,3,4,5};
System.out.println(Arrays.toString(i));
int l = i.length;
int[] m = new int[l];
int count = 0;
for(int n=l-1;n>=0;n--){
m[count] = i[n];
count++;
}
System.out.println(Arrays.toString(m));
}
}
结果为
上面的代码可以简化为
int[] arr= {6,7,8,9,10};
for(int s=0,e=arr.length-1; s<=e; s++,e--) {
int temp = arr[s];
arr[s] = arr[e];
arr[e] = temp;
}
System.out.println(Arrays.toString(arr));
结果是一样的
//方法二
int[] arr= {6,7,8,9,10};
for(int x=0; x<arr.length/2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
System.out.println(Arrays.toString(arr));
结果为
数组排序
int[] a = {12,5,16,53,42};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
结果为
冒泡排序
package test1;
import java.util.Arrays;
public class BubbleSort1 {
public static void main(String[] args) {
int[] a = {12,5,16,53,42};
int temp;
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j+1]>a[j]){
temp = a[j+1];
a[j+1] = a[j];
a[j] = temp;
}
}
}
for(int n:a){
System.out.println(n);
}
}
}
这里详细的解释一下，首先创建一个一维数组，里面的值为12,5,16,53,42，要想让数组按从大到小的顺序排列，就让数组之间的元素两两比较，先让最小的那个数字换到数组的最后面，就跟冒泡一样让最小数浮上去。然后以此类推，最小的数字到最后面后，剩下的几个数字再次两两比较，让最小的数字到倒数第二个位置。
具体的实现方法是双重for循环，外层for循环决定了两两对比几次，因为每一轮外循环结束后，都要有一个最小数到后面，剩下的数字再两两比较。而内层for循环则决定着具体比较的是哪两个数。如果下一个数字a[j+1]大于当前数字a[j]，那么两者交换位置。
关于循环里面的条件，外层for循环的条件是i<a.length-1，为什么这里要减一呢，因为每次都外层for循环结束，都会让一个元素沉下去，也许是沉到最后一位，也许是沉到倒数第三位。但最后一次外层for循环结束后，i=0指向的数组元素必然是最小的了。因为 i=a.length-2的时候就已经将倒数第二小的元素放在了 i=1 的位置。就没必要比较最后一个元素了。
内层for循环的条件是j<a.length-1-i，要减去1是因为循环内部有一个a[ j+1]，会比较最后一个元素。如果不减1，那么数组下标就要越界了。要减去 i 是因为 i 的值有多少，说明已经将多少个元素沉底了。每次内层for循环结束后，都会将最大的元素移动到数组的最后面，既然都已经是最大的元素了，就不用每次再进行比较了。
最后的结果为
二维数组
二维数组就是元素为一维数组的数组
语句格式为：
数据类型[][] 变量名 = new 变量名[m][n] ;
m表示的是这个二维数组有多少个元素，其中每一个元素都是一个一维数组
n表示的是这个二维数组中每个元素，也就是每个一维数组的长度
遍历二维数组的值
package test1;
public class ArrayDemo4 {
public static void main(String[] args) {
int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.println(a[i][j]);
}
}
}
}
结果为
二维数组输出杨辉三角
package test1;
import java.util.Scanner;
public class ArrayDemo5 {
public static void main(String[] args) {
//获取你想打印多少行杨辉三角
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//规律一，n行等于n列
int[][] arr = new int[num][num];
//规律二，每一行的第一列和最后一列的元素是1
for(int i=0;i<arr.length;i++){
arr[i][0] = 1;
arr[i][i] = 1;
}
//规律三，这一行的数据等于上一行的上一列+上一行的同一列
for(int i=2;i<arr.length;i++){
for(int j=1;j<i;j++){
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
}
//打印二维数组，输出最后的结果
for(int i=0;i<arr.length;i++){
for(int j=0;j<=i;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
结果为
杨辉三角的规律是
- 如果是n行，那么最后一行是n列。
- 每一行的第一列和最后一列的元素是1。
- 每一行的第二列开始数据是：上一行的上一列+上一行的同一列
扫一扫
919
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
