当程序中出现大量数据，则会需要创建大量的变量，显得比较麻烦
这些变量基本上类型都是相同的，那我们就可以用一个容器将所有的数字进行管理。类似于字符串，字符串其实就是若干个字符的容器而已，“abc”可以通过索引/角标老获取起中的一个字符。[1 ，2， 3，4，5，6]类似字符串能够可以通过所以或者角标来获取其中的一个数字呢，那么这个容器我们称之为数组
用途
数组主要解决多变量多数据的储存问题，方便后期进行调用
数组的本质
数组就是一系列空间大小相等且地址连续一片的储存空间
那么为什么空间大小是相等的呢？
为了保证数据之间的类型是相同的，方便以后进行调用。（多个同类型的变量连在一起组成的结构叫做数组）
为什么数组地址是连续呢
：为了方便操作
数组一旦定义下来拿起长度是不可改变了的，数组中有几个地址，那就看数组有几颗元素空间<==>数组的长度
数组的建立
1 数组类型 [ ] 数组名=new 数组类型 [长度]；创建数组至指定长度但不指定内容
2 数据类型 [ ] 数组名=new 数据类型 [ ]；{1,2,3,4,5}只指定内容，长度自然确定
3 数据类型 [ ] 数组名={1，2，3，4，5}；直接定义
先在堆内存中创建连续相等大小的空间，在主函数中创建一个数组变量arr，然后将连续空间的首地址存到这个变量，这是一个一维数组就创建好了。
数组创建（数组一维 矩阵二维）
class Q{
public static void main(String[] args){
new int[] arr=new int [5]//在堆内存中创建了一个数组,
System.out.println(arr[3])//打印的四个数，再打印的时候如果未赋值，在创建数组的时候，就已经提前对数组内容进行了初始化整数类型默认为0 浮点类默认为0.0 布尔类型默认为false 引用数据类型默认是空
String[] atrArr=new String[5];
System.out.println(arr[0]);//创建长度为5的String数组，未输入的话则打印结果为null（空）
//System.out.println(arr[10]);报错，数组角标越界Array IndexOutOfBoundsException
int [] arr2=arr;//创建了一个int型的数组arr2，此时数组对象未变，只是引用到了，将arr的地址给了arr2，一个数组变量有两个数组变量来
arr2[0]=10;
System.out.println(arr[0])//the result is 10
arr2=null；
System.out.println(arr2[0]);//NullPointerException 空指针异常， 因为之前的arr2已经是空了，所以打印不出什么，为空
arr=null;//此时此刻，数组对象没有任何意义，因为没有任何变量引用它，成为垃圾，最终会有垃圾回收器处理，垃圾回收期数JVM（虚拟机）的一个程序， 专门在垃圾攒到一定程度时将垃圾清楚
//特殊的在c++中如果出现了垃圾，必须由程序员手动进行处理 free函数释放内存
}
}
array 类
import java.util.*;
class Q{
public static void main(String[] args){
int[] arr = {1,3,5,6,4,8,9,4,2,6};
Array.Sort(arr);//对arr惊醒排序，
System.out.println(Array.binarySearch(arr,8));//用中心查找找寻角标为8的元素
arr=Arrays.copyOf(arr,arr.length+1);//对数组进行扩容，但直接打印的话最后一位会是0，因为还没有输入。
System.out.println(Arrray.toString(arr));//将数组内容返回为字符串表示形式
//public static boolean equals{}//判断俩个数组是否相等，相等的话，返回true
}
}
二维数组相关
class Q{
public static void main(String[] args){
int[][] matrix={
{1,2,3,4},
{5,6,7,8},
{4,3,2,1},
{4,6,7,8}
};
//matrix.length 表示的是最外层的一维数组的长度
//matrix[i] 表示的是最外层的那个一维数组当中角标i的那个元素 只不过这个元素也是一个一维数组
//matrix[i].length 表示的是这个数组的一维数组的长度
//matrix[i][j] 表示的是这个一维数组元素中表 j 那个元素
for(int i=0;i<martix.length;i++){
for(int j=0;i<matrix[i].length;i++){
System.out.println(matrix[i][j]+" ");
}
System.out.println();
}
//int[][] matrxi= new int[m][n]; 这个二维数组顶一下
//内存中有多少个一维数组 一共 m+1
}
}数组基本数据操作
数组 遍历
class Q{
public static void main(String[] args){
int[] arr={1,2,3,4,5,6,7,8,9};//[0,8]
//数组的唯一属性length 数组的长度
System.out.println(arr.length);
for(int i=0;i<=arr.length;i++){
System.out.println(arr[i]);
}
}
}
赋值操作
import java.util.Scannner
class Q{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int[] arr2=new int [10];
for(int i=0;i<arr2.length;i++){
arr[i]=in.nextInt();
}
}
}找最大值/最小值
import java.util.Scanner;
class Q{
public static void main(String[] args){
int[] arr={10,2,3,4,5,6,8,9,4};
int max_arr[0];
int min_arrindex=0;
for(i=0;i<arr.length;i++){
if(arr[]i>max){
max=arr[i];
}
if(arr[i]<arr[min_index]){
min_index=i;
}
}
System.out.println("the max ="+max);
System.out.println("thr minmum index is"+min_index);
}
}数组的扩容
class Q{
public static void main(String[] args){
int[] arr= new int[]{1,2,3};
arr=copyOf(arr,arr.length+1);
arr[arr.length-1]=10;
System.out,println(arr[3]);
}
public static int[] copyOf(int[] ,int newLen){
int[] newArr=new int[newLen];
for(int i=0;i<arr.length;i++){
newArr[i]=arr[i];
}
return newArr;
}
}排序方法
class Q{
public static void main(String[] args){
selectSort();//选择排序
bubbleSort();//冒泡排序
insertSort();//插入排序
countSort();//基数排序
}
public static void countSort(){
int[] arr={8,5,9,6,4,2,6,7,1,3,2};
int min=arr[0];
int max=arr[0];
for(int i=0;i<arr.length;i++){
if(arr[i]>max){
max=arr[i];
}if(arr[i]<min){
min=arr[i];
}
}
int[] nums=new int[max-min+1];
int offset=min;
for(int i=0;i<arr.length;i++){
nums[arr[i]-offset]++;
}
int index=0;
for(int i=0;i<nums.length;i++){
if(nums[i]!=0){
for(int j=0;j<nums.length;j++){
arr[index++]=i+offset;
}
}
}
show(arr);
}
public static void insertSort(){
int[] arr={8,5,9,2,7,6,4};
int e;
int j;
for(int i=0;i<arr.length;i++){
e=arr[i];
for(int j=0;j>0&&arr[j-1]>e;j--){
arr[j]=arr[j-1];
}arr[j]=e;
}
show(arr);
}
public static void bubble(){
int[] arr{8,6,3,4,8,7,5};
for(int i=0;i<arr.length-1,i++){
//-1是少一轮比较
for(int j=0;j<arrlength-1-i;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}
}
show(arr);
}
public static void selectSort(){
int[] arr={8,7,4,9,6,3,5};
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j，arr.length;j++){
if(arr[i]>arr[j]){
swap(arr,i,j);//即用即释放
}
}
}show(arr);
}
public static void swap(int[] arr,int i,int j){
/*
1借助第三方变量进行交换，适用于所有数据类型比较通用。
int temp=arr[i];
arr[i]=arr[j];
arr[j]<temp;
2 借助加减法进行计算交换，只适用于数字型馆的数据类型
arr[i]=arr[i]+arr[j];
arr[j]=arr[i]-arr[j];
arr[j]=arr[i]-arr[j];
}
}
某个元素在数组中所在的位置
class Q{
public static void main(String[] args){
linearsearch();//线性查找
binarysearch();//二分查找（前提是数组是有序的）
}
public static void linearsearch(){
int[] arr={10,1,2,4,56,9,8,4,5,6};
int key=11;
int index=-1;
for(int i=0;i<arr.length;i++){
if(arr[i]==key){
index=i;
break;
}
}
System.out.println(index);
}
public static void binatrysearvh(){
int[] arr={12,17,21,32,38,41,46,49,40,41,46,49,50,51,59,60}
int key=12;
int index=-1;
int min_index=0;
int max_index=arr.length-1;
int mid_index=(min_index+max_index)/2;
while(arr[mid_index]!=key){
if(arr[min_index]>key){
max_index=min_index-1;
}
if(arr[mid_index]<key){
min_index=min_index+1;
}
if(min_index>max_index){
intdex=-1;
break;
}
mid_index=(min_index+max_index)/2
}
System.out.println(mid_index);
}
}
import java.util.*;
class Q501{
public static void main(){
Scanner scanner=new Scaner(system.in);
int []num=new int[101];//创建数组
System.out.println("enter numbers of ending with 0");
}
while(true){
int a=scanner.nextInt;
if(a!=0){
num[a]++;
}
else{
break;
}
}
for(int i=0;i<101;i++){
if(num[i]!=0){
if(num[i]>1){
System.out.println(i+"occur"+num[i]"times");
}
else{
System.out.println(i+"occur"+num[i]"time");
}
}
}
}}
import java.util.*;
class Q502{
public static void main(String[] args){
Scanner scanner =new Scanner(System.in);
int []num=new int[10];
int count=0;
System.out.println("enter 10 numbers");
for(int i=0;i<10;i++){
int k=1;
int n=scanner.nextInt();
for(int j=0;j<=count;j++){
if(num[j]==n){
k=1;
}
if(k==1){
num[count]=n;
count++
}
}
for(int i=0;i<count;i++){
System.out.println(num[i]);
}
}
}
}
import java.util.*;
class Q503{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int n=scanner.nextInt;
int []num=new int[n];
for(int i=0;i<n;i++){
int m=scanner.nextInt;
num[i]=m;
}
if(isSoft(num)){
System.out.println("ok"
)
}
else{
System.out.printlln("no");
}
}
public static boolean isSoft(int[] list){
for(int i=0;i<list.length-1;i++){
if(list[i+1]<list[i])
return false;
}
return true;
}
}
import java.util.*;
class Q504{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("Enter the number of balls to drop");
int balls = scanner.nextInt();
System.out.println("Enter a number of slots in the bean machine");
int[] arr=new int[solts];
//几个球几个路径
for(int i=0;i<balls;i++){
String path = getPath(slot);
System.out.println(path);
//只要看当前路径中R的个数即可
arr[getR(Path)]++;
//输出
}
System.out.println(path);
show(arr);
}
public static void show(int[] arr);
int w=ar.length;
int h=0;
for(int i=0;i<arr.length;i++){
if(<arr.[j]){
System.out.println("O");
}else{
System.out.println(" ");
}
System.out.println();
}
public static int getR(String path){
int count=0;
for(int i=0;i<path.length;i++){
if(path.charAt(i)=='R');{
count++;
}
}
return count;
}
public static String getPath(int slots){
Random=nextInt(2);
String path ="";
for(int j=0;j<slots;i++){
if(random.nextInt(2)==0){
path+="L";
}else{
path+="R";
}
}
return path;
}
}.
import.java.util.*;
class Q505{
public static void main(String[] args){
Scanner scanner=new scanner(System.in);
int n=scanner.nextInt();
int []a=new int[n];
for(int i=0;i<n;i++){
a[i]=scanner.nextInt();
}
int m=scanner.nextint();
int []b=new int[m];
for(int i=0;i<m;i++){
b[i]=scanner.nextInt();
}
if(equals(a,b)){
System.out.println("yes");
}
else{
System.out.println("no");
}
}
public static boolean equals(int []a,int []b){
for(int i=0;i<a,length;i++){
if(a[i]!=b[i]){
return false;
}
}
return true;
}
}
class Q506{
public static void main(String[] args){
int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,4};
for(int i=0;i<arr.length;){
int count=1;
for(int j=i+1;j<arr.length;j++){
if(arr[i]<arr[j]){
count++;
}else{
break;
}
}
if(count>=4){
System.out.println(arr[i]);
return;
}
i+=count;
}
System.out.println("没有")；
}
}.
import java.util.*;
class Q507{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in）;
int[] list1={1,3,5,7,9};
int[] list2={2,4,6,8,10};
System.out.println(Arrats.to.String(merge(list1,list2)));
//有序数组的合并主要在于数组之间有长短
}
public static int[] merge(int[] list1,int[] list2){
if(list==null&&list2==null){
return null;
}
if(list1==null){
return list2;
}
if(list2==null){
return list1;
}
//只有两个都不是null的情况在考虑具体操作
int[] list3 = new int[list1.length.+list2.length];
int p=0;
int p2=0;
int p3=0;
while(true){
if(p1==list1.th&&p2==list2.length){
break;
}
if(p1<list.length&&p2==list.length){
list3[p3++]=ist2[p2++];
}else if(p1==list.length&&p2<list.length){
list3[p3++]=list[p1++];
}else{
if(list1[p1]<=list2[p2]){
list3[p3++]=list[p1++];
}else{
list3[p3++]=list[p2++];
}
}
}
return list3;
}
}
import java.util.*;
class Q507{
public static void main(String[] args){
/*
一组单词的明文， 单词的密文 单词的状态
program
1000000 r r
pr**r**
*/
Scanner scanner = new Scanner.(System.in);
Random ramdom = new Random();
//1创建一个单词表
String[] words={"naruto","kakashi","banana","java","program"};
//2随即从单词表抽出一个单词
String word=words[random.nextInt(word.length)];
//3创建一个该单词的状态表,默认为false（密文）
boolean[] status= new boolean[words.length];
int miss=0;//猜错个数
//4开始猜一个单词
while(true){
//5根据单词的状态表 决定密文形式
String cipherttext=getCupherText(word,status);
//6输出密文并提示用户输入字母
System.out.println("Enter a letter in word"+chiphretext+">");
char letter=scanner.nextline.charAt(0);//输入所猜测的字母
//判断是否存在该字母
if(isContainsLetter(word,letter)){
//改变但此状态表 已修改/未修改
//true 表示第一次来的
//false 表示不是第一次来的
if(!changeWordStatus(word,status,letter)){
System.out.println("\t"+letter"is already in the word");
}else{
System.out.println("\t"+letter+"is not in the word");
miss++;
}
//9 是否结束
if(isFinish(status)){
System.out.println("the word is "+word+"you miss"+miss+"time(s)");
break;
}
}
}
}
public static boolean isfinish(boolean[] status){
for(int i=0;i<status.length;i++){
if(!status[i]){
return false;
}
}
return true;
}
public static boolean changeWordStatus(String word,boolean[] status,char letter){
for(int i=0;i<word.length;i++){
if(word.charAt(i)==letter){
if(status[i]){
return false;//说明已经修改
}else{
status[i]=true;
}
}
}
return true;
}
public static boolean isContainsLetter(String[] word,char letter){
String ciphertext="";
for(int i=0;i<status.length;i++){
if(status[i]){
ciphertext+=word.charAt(i);
}else{
ciphertext+="*";
}
}
return ciphertext;
}
}
//显示一个矩阵的每列之和
import java.util.*;
class Q509{
public static void main(String[] args){ //累加行的时候 行不动列动
//累加列的时候 列不动行东
//输入一个3*4的矩阵
Scanner scanner = new Scanner(System.in);
System.out.println("enter numbers");
double[][] matrix = new double[3][4];
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){\
matrix[i][j]=scanner.nextDuble();
}
}
//打印每行的和
for(int col=0;col<matrix[0].length;col++){
System.out.println(sumColumn(matrx,col));
}
}
public static double sumColumn(double[][] m,int col){
double sum=0;
for(int row=0;row<m.length；row++){
sum+=m[row][col];
}
return sum;
}
}
从左上到右下是主对角线
从右上到左下数
import java.util.*;
class Q510{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int[][] matrix = new int[][];
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){
matrix[i][j]=scanner.nextInt();
}
}
//主对角线
int sum = 0;
for(int i = 0;i < matrix.length;i++){
sum+ = m[i][j];
}
System.out.println("主对角线的值");
//副对角线
int subsum = 0;
for(int i = 0;i < matrix.length;i++){
subsum+ = m[i][matrix.length-1-i];
}
System.out.println("副对角线的值");
/*
for(int i=0;i<matrix.length;i++){
for(int j=0;j<matrix[i].length;j++){
if(i==j){
sum+=matrix[i][j];
}
}
}
*/
}
}i
/*
m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
/*
1 2 3 1 2 1*1+2*3+3*5 1*2+2*4+3*6
× 3 4 =
4 5 6 5 6 4*1+5*3+6*5 4*2+5*4+6*6
对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
此时推荐使用已知公式计算！
*/
import java.util.*;
class Q511{
public static void main(String[] args){
double[][] A = {
{1,2,3},
{4,5,6},
{7,8,9},
}
double[][] B={ //p*n
{0,2.0,4.0},
{1,4.5,2.2},
{1.1,4.3,5.2}
};
double[][] C=new double[A.length][B[0].length];//m*n
for(int i=0;i<C.length;i++){
for(int j=0;j<C[i].length;j++){
double sum=0;
for(int k=0;k<B.length;k++){
sum+=A[i][k]*B[k][j];
}
C[i][j]=sum;
System.out.print(C[i][j]+" ");
}
System.out.println();
}
}
import java.util.*;
class Q512{
public static void main(String[] args){
//1 输入一个方阵 创建方阵
// 方阵的长和宽是一样的
Scanner scanner = new Scanner(System.in);
System.out.println("enter size")；
int size = scanner.nextInt();
int m[][] = new int[size][size];
//2 随即输入0 和 1
Random random=new Random();
for(int i=0;i<size;i++){
for(int j=0;j<size;j++){
m[i][j]=random.nextInt(2);
System.out.print(m[i][j]+" ");
}
System.out.println();
}
//3.让行，列，对角线累加 sum==0 sum==size 表示全相等
checkRow(m);
checkCol(m);
checkDiagonal(m);
checkSubDiagonal(m);
}
public static void checkSubDiagonal(int[][] m){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][m.length-1-i];
}
if(sum==m.length||sum==0){
System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
}
}
public static void checkDiagonal(int[][] m){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][i];
}
if(sum==m.length||sum==0){
System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
}
}
public static void checkRow(int[][] m){
for(int i=0;i<m.length;i++){
int sum=0;
for(int j=0;j<m[i].length;j++){
sum+=m[i][j];
}
if(sum==m.length||sum==0){
System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
}
}
}
public static void checkCol(int[][] m){
for(int j=0;j<m.length;j++){
int sum=0;
for(int i=0;i<m.length;i++){
sum+=m[i][j];
}
if(sum==m.length||sum==0){
System.out.printf("第%d列全相等且是%d\n",j+1,sum==0?0:1);
}
}
}
}
import java.util.*;
class Demo05_13{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter row ,col:");
int row=scanner.nextInt();
int col=scanner.nextInt();
int[][] m=new int[row][col];
for(int i=0;i<row;i++){
for(int j=0;j<col;j++){
m[i][j]=scanner.nextInt();
}
}
System.out.println(isConsecutiveFour(m));
}
public static boolean isConsecutiveFour(int[][] m){
for(int i=0;i<m.length;i++){
for(int j=0;j<m[i].length;j++){
//向右
if(j<=m[i].length-4){
boolean flag=true;
for(int c=j+1;c<=j+3;c++){
if(m[i][j]!=m[i][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向下
if(i<=m.length-4){
boolean flag=true;
for(int r=i+1;r<=i+3;r++){
if(m[i][j]!=m[r][j]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向右下
if(i<=m.length-4&&j<=m[0].length-4){
boolean flag=true;
for(int r=i+1,c=j+1;r<=i+3;r++,c++){
if(m[i][j]!=m[r][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
//向右上
if(i>=3&&j<=m[0].length-4){
boolean flag=true;
for(int r=i-1,c=j+1;c<=j+3;r--,c++){
if(m[i][j]!=m[r][c]){
flag=false;
break;
}
}
if(flag){
return true;
}
}
}
}
return false;//四个方向都没有连续的
}
}
扫一扫
960
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
