数组的定义
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
数组的概念
- 数组表示的一串连续的存储空间。每个空间中都可以保存一个数据。
- 当我们需要操作的时候，不是去面对单个空间，而是直接面对这个整体的连续的存储区域。
数组的定义方式
动态初始化
数据类型[] 数组名 = new 数据类型[长度] ;
静态初始化
数据类型[] 数组名 = {元素1，元素2，x,y,z,….};
数组的默认初始化值为0
多维数组
- 前面维度里的元素的内存里存的是后面的维度的内存地址
- int[1][2][3][4][5][6]
- [1]维有一个元素，存的是一个[2]维的地址。[2]维有两个元素存的是两个[3]维的地址。
- [3]维有3个元素，存的是3个[4]维的地址…依次类推，直到最后一维，最后一维存的是数组元素
- 所以JAVA多维数组可以看作是嵌套的矩阵,
- 矩阵包含子矩阵,子矩阵包含子子矩阵…依次类推，直到基本单位数组及其元素
创建一个六维数组：
int [][][][][][] array = new int[1][2][3][4][5][6];
创建一个1行4列的矩阵，每个矩阵包含一个2行5列的子矩阵,每个子矩阵3行6列(3个数组,每个数组长度为6)
- 简单来说就是创建1*2*3*4*5=120个数组，每个数组的长度为6
实例：
一维数组合并
public static int[] arrsum(int[] arr,int[] arr1){//数组合并
int start=arr.length;
arr=Arrays.copyOf(arr, arr.length+arr1.length);//数组扩容
for(int i=start,x=0;i<arr.length;i++,x++){
arr[i]=arr1[x];
}
System.out.println(Arrays.toString(arr));
return arr;
}一维数组插入
private static void insert() {
int[] array=new int[10];
for(int i=0;i<10;i++){
array[i]=new Random().nextInt(50);
}
Arrays.sort(array);
System.out.println(Arrays.toString(array)+"\n请输入要插入的数字(0-50)");
Scanner in = new Scanner(System.in);
int x = in.nextInt();
array=Arrays.copyOf(array, array.length+1);
array[array.length-1]=x;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
Start();
}一维数组截取
import java.util.Arrays;
import java.util.Random;
public class arrapcopy {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr=new int[10];
int[] arr2=new int[10];
for(int i=0;i<10;i++){
arr[i]=new Random().nextInt(10)+1;
}
System.out.println(Arrays.toString(arr));
System.arraycopy(arr, 3, arr2, 3, 2);
System.out.print(Arrays.toString(arr2));
}
}
[3, 9, 7, 7, 2, 4, 9, 4, 7, 7]
[0, 0, 0, 7, 2, 0, 0, 0, 0, 0]
二维数组创建
public static void main(String[] args) {
int [][]array = new int[3][10];
for(int i=0;i<array.length;i++) {
for(int x=0;x<array[i].length;x++) {
array[i][x]=new Random().nextInt(90)+10;
}
}
for(int[]x:array) {//输出
System.out.println(Arrays.toString(x));
}
}二维数组遍历
public static void out(int [][] array) {
for(int [] i :array) {
for(int x:i) {
System.out.print(x+",");
}
}
}二维数组转一维
public static void copy(int[][]array) {
int len= array.length*array[0].length ;
int[] arr=new int [len];
int v=0;
for(int[] x:array) {
for(int i:x) {
arr[v]=i;
v++;
}
}
return arr;
System.out.println(Arrays.toString(arr));
}三维数组创建与遍历
import java.util.Arrays;
import java.util.Random;
public class 三维数组 {
public static void main(String[] args) {
int[][][]array=new int[3][3][3];
//创建3行3列的数组矩阵，矩阵元素即是数组的地址，3*3=9个数组，每数组个长度为3
//int[行][列][数组长度]
for(int i=0;i<array.length;i++) {
for(int x=0;x<array[i].length;x++) {
for(int y=0;y<array[i][x].length;y++)
array[i][x][y]=new Random().nextInt(90)+10;
}
}
//遍历array[矩阵行][矩阵列][数组列]
System.out.println(array[1][0][1]);
for(int[][]x:array) {
for(int y[] :x) {
System.out.print(Arrays.toString(y)+"\t");
}System.out.println("\n");
}
}
}
//取元素：array[数组行][数组列][元素列]
//array[1][0][1]：第2行第1列的数组的第2个元素
四维数组的遍历与创建
import java.util.Arrays;
import java.util.Random;
public class 四维数组 {
public static void main(String[] args) {
int[][][][]array=new int[3][3][3][3];
//创建一个3行3列的数组矩阵,每个矩阵元素包含三个数组,每个数组长度为3；
//创建一个3行3列的矩阵,每个矩阵包含一个3行3列的子矩阵
for(int i=0;i<array.length;i++) {
for(int x=0;x<array[i].length;x++) {
for(int y=0;y<array[i][x].length;y++) {
for(int z=0;z<array[i][x][y].length;z++) {
array[i][x][y][z]=new Random().nextInt(90)+10;
}
}
}
}
System.out.println(array[1][1][1][0]);//取元素
for(int[][][]x:array) { //遍历
for(int[][]y:x) {
for(int[]z:y) {
System.out.print(Arrays.toString(z)+"\t");
}System.out.println("");
}System.out.println("");
}
}
}
//取元素： array[矩阵行][数组行][矩阵列][数组列]
//取元素： array[矩阵行][子矩阵行][矩阵列][子矩阵列]
//array[1][1][1][0]：在坐标为第2行第2列的子矩阵中取坐标为第2行第一列的元素
六维数组的创建与遍历
import java.util.Arrays;
import java.util.Random;
public class 六维数组 {
public static void main(String[] args) {
int[][][][][][]array=new int[2][3][3][2][2][3];
//创建2*3*3*2*2个数组，每个长度为3（取决于最后一维）
//创建2*2个3行2列的数组矩阵,每个矩阵元素包含三个数组,每个数组长度为3；
//创建一个2行2列的矩阵，每个矩阵包含一个3行2列的子矩阵,每个子矩阵3行3列(3个数组,每个数组长度为3)
for(int i=0;i<array.length;i++) {
for(int x=0;x<array[i].length;x++) {
for(int y=0;y<array[i][x].length;y++) {
for(int z=0;z<array[i][x][y].length;z++) {
for(int n=0;n<array[i][x][y][z].length;n++) {
for(int m=0;m<array[i][x][y][z][n].length;m++) {
array[i][x][y][z][n][m]=new Random().nextInt(90)+10;
}
}
}
}
}
}
//多维数组专用输出方法deepToString();
System.out.println(Arrays.deepToString(array));
//取元素： array[矩阵行][数组行][矩阵列][数组列]
//取元素： array[矩阵行][子矩阵行][子子矩阵行][矩阵列][子矩阵列][子子矩阵列]
System.out.println(array[1][0][0][1][0][0]);
for(int[][][][][]x:array) {
for(int[][][][]y:x) {
for(int[][][]z:y) {
for(int[][]n:z) {
for(int[]m:n) {
System.out.print(Arrays.toString(m)+"\t");
}System.out.print("||\t");
}System.out.println();
}System.out.println();
}System.out.println("==============
===========================================================");
}
}
}
取元素：array[1][0][0][1][0][0]取坐标为第二行第二列的子矩阵中坐标为第一行第一列的子子矩阵中第一行数组的第一个元素
七维八维N维数组依此类推；
练习
package Endless;
/**
* @JAVA07.task.java
* @author 当前用户：Endless作者 :Endless
* @version 创建时间：2017年8月2日 下午4:53:46
* 1,有30个0~9之间的数字，分别统计0~9这10个数字分别出现了多少次
* 2,定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！
* 3,在排序好的数组中添加一个数字，将添加后的数字插入到数组合适的位置。
* 4,编写程序求1！+2！+.........30！的和并显示
* 5,1*1 + 1*1*2 + 1*1*2*3 + 1*1*2*3*4 +
* 6,定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数。
* 7,现在定义如下的一个数组：int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5},要求将以上数组中值为0的去掉，将不为0的值存入一个新的数组，生成的新数组为：int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
* 8,定义一个整型数组，求出数组元素的和、数组元素的最大值和最小值，并输出所求结果。
* 9,给出10个整数（int型），然后任意查询一个数字是否存在该10个数字内
* 10,定义一个包含10个元素的数组，对其进行赋值，使每个元素的值等于其下标，然后输出；最后将这个数组倒置后输出
* 11,给出10个老师的打分，对10个老师的打分打到最高分
*/
import java.security.KeyStore.Entry;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
public class task {
public static void main(String[] args) {
Start();
}
@SuppressWarnings({ "resource" })
private static void Start() {
// TODO Auto-generated method stub
System.out.println(""
+ "1,有30个0~9之间的数字，分别统计0~9这10个数字分别出现了多少次\n"
+ "2,定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！\n"
+ "3,在排序好的数组中添加一个数字，将添加后的数字插入到数组合适的位置。\n"
+ "4,编写程序求1！+2！+.........30！的和并显示\n"
+ "5,1*1 + 1*1*2 + 1*1*2*3 + 1*1*2*3*4\\n "
+ "6,定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数\n"
+ "7,要求将数组中值为0的去掉，将不为0的值存入一个新的数组\n"
+ "8,定义一个整型数组，求出数组元素的和、数组元素的最大值和最小值，并输出所求结果。\n"
+ "9,给出10个整数（int型），然后任意查询一个数字是否存在该10个数字内\n"
+ "10,定义一个包含10个元素的数组，对其进行赋值，使每个元素的值等于其下标，然后输出；最后将这个数组倒置后输出\n"
+ "11,给出10个老师的打分，输出最高分\n");
Scanner in =new Scanner(System.in);
int x = 0;
try {
x=in.nextInt();
} catch (Exception e) {
Start();
}
switch (x) {
case 0:
System.exit(0);
break;
case 1:
numsum();
case 2:
exmax();
break;
case 3:
insert();
break;
case 4:
Seqnum1();
break;
case 5:
Seqnum();
break;
case 6:
odd();
case 7:
cls0();
break;
case 8:
printall();
break;
case 9:
select();
break;
case 10:
index();
break;
case 11:
max();
break;
default:
System.out.println("没有此选项");
Start();
break;
}
}
private static void max() {
// TODO Auto-generated method stub
int [] array=new int [10];
for(int i=0;i<10;i++) {
array[i]=new Random().nextInt(100)+1;
}
System.out.println(Arrays.toString(array));
int max =array[0];
for(int i=0;i<array.length;i++) {
if(max<array[i]) {
max=array[i];
}
}
System.out.println("最高分："+max);
}
private static void index() {
// TODO Auto-generated method stub
int [] array=new int [10];
int [] arr=new int[array.length];
for(int i=0;i<10;i++) {
array[i]=i;
}
System.out.println(Arrays.toString(array));
for(int i=1;i<array.length;i++) {
arr[i-1]=array[array.length-i];
}
System.out.println(Arrays.toString(arr));
Start();
}
private static void select() {
// 查找数组是否存在某个元素
int[] array=new int[10];
for(int i=0;i<10;i++){
array[i]=new Random().nextInt(50);
}
Scanner in = new Scanner(System.in);
System.out.println("请输入要查询的数字：");
int n=in.nextInt();
System.out.println(Arrays.toString(array));
boolean z = false;
for(int x:array) {
if(n==x) {
z=true;
break;
}
}
if(z) {
System.out.println("在");
}else {
System.out.println("不在");
}
Start();
}
private static void printall() {
// 数组元素的最值及其元素之和
int[] array=new int[10];
for(int i=0;i<10;i++){
array[i]=new Random().nextInt(50);
}
Arrays.sort(array);
System.out.println(Arrays.toString(array)+"\n最大值："+array[array.length-1]+"\t最小值："+array[0]);
int sum = 0;
for(int i=0;i<array.length;i++) {
sum=sum+array[i];
}System.out.println("元素之和为："+sum);
Start();
}
private static void cls0() {
//元素筛选
int sum=0,k=0;
int[]array= {1,2,8,6,0,6,0,2,0,9};
System.out.println(Arrays.toString(array));
for(int x:array) {
if(x==0) {
sum++;
}
}
int[] newarr =new int[array.length-sum];
for(int i=0;i<array.length;i++) {
if(array[i]!=0) {
newarr[k]=array[i];
k++;
}
}
System.out.println(Arrays.toString(newarr));
Start();
}
private static void odd() {
// TODO Auto-generated method stub
int[] array=new int[10];
for(int i=0;i<10;i++){
array[i]=new Random().nextInt(50);
}
int ou = 0,ji = 0;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
for(int x:array) {
if(x%2==0) {
ou++;
}else if(x%10!=0) {
ji++;
}
}System.out.println("奇数："+ji+"个\n偶数："+ou+"个");
Start();
}
private static void Seqnum1() {
// TODO Auto-generated method stub
//1-30的阶乘和
int n=30;
int x=1;
long sum=0;
for(int i=1;i<=n;i++) {
x*=i;
sum+=x;
System.out.println(sum);
}
Start();
}
private static void Seqnum() {
int n=3;
int sum=1;
for(int i=1;i<=n;i++) {
sum+=sum*i;
}
System.out.println(sum);
}
private static void insert() {
// TODO Auto-generated method stub
int[] array=new int[10];
for(int i=0;i<10;i++){
array[i]=new Random().nextInt(50);
}
Arrays.sort(array);
System.out.println(Arrays.toString(array)+"\n请输入要插入的数字(0-50)");
Scanner in = new Scanner(System.in);
int x = in.nextInt();
array=Arrays.copyOf(array, array.length+1);
array[array.length-1]=x;
Arrays.sort(array);
System.out.println(Arrays.toString(array));
Start();
}
private static void exmax() {
// TODO Auto-generated method stub
int[] arr = new int[30];
for(int i=0;i<30;i++){
arr[i]=new Random().nextInt(10);
}
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// int max =arr[arr.length-1];
// arr[arr.length-1]=arr[0];
// arr[0]=max;
arr[0]=arr[arr.length-1]^arr[0];
arr[arr.length-1]=arr[arr.length-1]^arr[0];
arr[0]=arr[arr.length-1]^arr[0];
System.out.println(Arrays.toString(arr));
Start();
}
@SuppressWarnings("unchecked")
private static <T> void numsum() {
String[] arr = new String[30];
for(int i=0;i<30;i++){
arr[i]=Integer.toString(new Random().nextInt(10));
}
Map<String, Integer> map = new HashMap<>();
for (String str : arr) {
Integer num = map.get(str);
map.put(str, num == null ? 1 : num + 1);
}
Set set = map.entrySet();
Iterator it = set.iterator();
System.out.println(Arrays.toString(arr));
System.out.println("方法一 ：");
while (it.hasNext()) {
Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>) it.next();
System.out.println(entry.getKey() + "出现次数 : " + entry.getValue());
}
System.out.println("方法二 ：");
Iterator it01 = map.keySet().iterator();
System.out.println();
while (it01.hasNext()) {
Object key = it01.next();
System.out.println(key + "出现次数 : " + map.get(key));
}
}
}
710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
