JAVA基础知识3（数组）

最新推荐文章于 2022-10-25 08:58:52 发布

JQ210245253

最新推荐文章于 2022-10-25 08:58:52 发布

阅读量860

点赞数

CC 4.0 BY-SA版权

分类专栏： JavaWeb

本文链接：https://blog.youkuaiyun.com/JQ210245253/article/details/82631450

JavaWeb 专栏收录该内容

30 篇文章

订阅专栏

这篇博客详细介绍了JAVA中的一维和二维数组的声明、初始化、操作以及相关方法，如获取数组长度、格式化打印、填充、排序、复制和查询等。此外，还讲解了如何使用`toString`、`random`方法，并讨论了`equals`的用法。博客还涵盖了二维数组的不同创建方式，以及如何通过`for`和`foreach`循环遍历和操作数组。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.一维数组

1.声明数组并且为它分配内存。

C++中：

int *a = new int[10];

JAVA中摒弃了指针的形式，变为

int a[] = new int [10];.//表示该数组可以存储十个元素

如果没有进行初始化的话，int里为0，String为null.

2取得数组的长度

a.length表示的是他的数组的元素个数，比如上例就是10.

3.数组练习（格式化打印输出）

***ToString的使用和random的使用方法，标要记箭头的为多注意的地方

例2：查找对应的姓名

eg：

String nameArr[]=new int[3];
for(int i=0;i<3;i++)
{
   nameArr[i]=scan.next();//如果是整数位scan.nextInt();
}

//根据输入的内容查找对的名字
String name=scan.next();
for(int i=0'i<3;i++)
{
if(nameArr[i].equals(name)
{
   输出
}
}

最主要的还是equals的用法

二.二维数组

1.二维数组的初始化

eg;

int arr[][] = {value1,value2,...valuen};

**2.创建一个2*3二维数组**

arr=new int[2][3];

length=2

a[0]

a[1]

//一横行长度为3

arr[0][0]	arr[0][1]	arr[0][2]
arr[1][0]	arr[1][1]	arr[1][2]

3.java中定义二维数组的方式

1. 先定义，再分配空间

int [][]x;

x=new int[2][2];

2. 定义和分配空间同时

int [][]x=new int[2][2];

3. 不规则数组

int [][]x=new int[2][];

x[0]=new int[3];

x[1]=new int[4];

4.定义的同时赋值

int [][]x={{1,1},{2,2}};

5.定义不规则的数组同时赋值

int [][]x=new int[][]{{1,1},{1,2,3}};

或者

int [][]x={{1,1},{1,2,3}};//4和5是差不多的

2.使用二维数组

2.1输出二维数组的for语句

int a[][]=new int [2][3];
for(int i=0;i<a.length；i++)
{
    for(int j=0;j<a[i].length;j++)
   {
     输出a[i][j];
   }
}

解析：a.length指的是集合中的集合（后面的以此类推），第二行的for语句为在第一行的集合中进行的循环为a[i].length 。

eg：int a[] []={{1,2,3,4},{5,6,7,8},{10,11,12,13}；

第一行就是在大集合的三个集合中的循环，为集合中的三个集合中循环

第二行额就是在大集合中小集合四个数中进行的循环，为a[0]的长度中循环，a[1]的循环中中，a[2]的循环中，所以要表示每个数组的长度时至少得加上下标。

2.2输出二维数组的foreach语句

首先回顾foreach用法

for(元素变量x(不必初始化）：遍历对象obj){引用x的java语句；}

eg:int a[]={1,2,3}；

for（int x:a）{打印输出}//a指定要循环遍历的数组。

上面是一维，现在来看二维

public class Testforeach{
public static void main(String[] args){
int [][]num={{1,2,3},{11,22,33},{111,222,333}}；
for(int a[]:num)
   for(int b:a){
       System.out.println(b);
      }
   }
}
}

可以看出第一行的for先是输出一个整形数组,联系上面的集合的部分

是大集合中的三个小集合，所以是一个数组，后面是对象（数组名）

然后第二行是先输出数组中的各部分，可以当程以一维数组来看待即可。

2.2.1（数组的方法-填充）

fill(int[]a, int value)//对一般的空数组进行填充Array.fill(,)即可 fill(int[]a,int fromdex,int todex,int value)//填充数量（后面下标- 前面下标）

2.2.2（数组的方法-排序）

Array.sort(object)//结果是从小打大

2.2.3 (数组的方法-复制)

1.copyOf(arr,int newlength)//如果新的长度大则用0补充，反之，则截取到哪就是哪

该1,2方法提供多种重载形式，用于满足不同类型的数组的复制。

2.copyOfRange(arr,int fromdex,int todex)

2.24 （数组的方法-查询）

1.binarySearch(object[] a,object key)

返回类型->搜索元素的索引（下标）

1.1key在数组中则返回下标即可，

1.2key小于数组的任何一个元素返回-1.

1.3key不在数组返回-(插入点)，（大于数组最小元素下标从1开始计数）

eg：int []b=new int [{4,25,10,95,06,21};

Arrays.sort(b);

int index= Arrays.binarySearch(b,2); -1

int index= Arrays.binarySearch(b,20); -4

int index= Arrays.binarySearch(b,30); -6

int index= Arrays.binarySearch(b,100); -7(下标从1开始）

int index= Arrays.binarySearch(b,10);

2 .binarySearch(object[] a,int Fromdex,int Todex,bject key)

2.1 key在数组中则返回下标即可

2.2 key在搜索范围内，但不在数组中，由1开始计数

2.3 key大于数组元素，返回-(endIndex+1);

2.4key不在搜索范围内，切小于范围内元素。由1开始计数

3.数组排序

3.1.冒泡排序：两者交换，大的往后，外层控制比较轮数（元素数-1，剩下的一轮就不用交换），内层用于控制比较数组中相邻元素的大小，以确定是否交换位置，交换的次数随着轮数的增大而减少。

//小到大

for(int i=1;i<a.length;i++)
   for(int j=0;j<a.length-i;j++)
       {
           if(a[j]>a[j+1]
             {
                 交换
             }
        }

3.2选择排序

package SELECT;

public class SortSelect {

	public static void main(String[] args) {
		int a[]= {1,2,3,5,4};
		//创建一个SELECTSORT对象
		SELECTSORT sorter=new  SELECTSORT();
		sorter.sort(a);
		for(int i:a) {
			System.out.println(">"+i);
		}
	}
}
		
class SELECTSORT{ //把排序算法封装到sort中
	public void sort(int a[]) {
		int temp=0;
		for(int i=0;i<a.length-1;i++)
		{
			int min=a[i];
			int minIndex=i;//假设第一个为最小值，记录下标，后面以此类推
			   for(int j=i+1;j<a.length;j++)
			   {
			    if(a[j]<min)//从紧接着的后面开始判断，知道一轮循环完毕，找到最小值，记录他的下标
			    {
			    	min=a[j];//找到最小值
			    	minIndex=j;//记录他的下标
			    }
			   	
			   }//当循环完for语句时，也就是所有的值都遍历完了，就找出了最小值
			  temp =a[i];
			  a[i]=a[minIndex];//用找到的最小值下标和刚开始认为最小的值进行交换
			  a[minIndex]=temp;
			      //交换完后第一个就是最小值，以此类推，从小到大
			}
	}
}

4. 插入排序

//关键点在代码中。

package SELECT;

public class SortInsert {

	public static void main(String[] args) {
		int a[]= {1,4,2,3};
		INSERTSORT sorter= new INSERTSORT();
		sorter.sort(a);
		for(int x:a)
			System.out.println(x);
	}
}
class INSERTSORT{                //递增排序
	public void sort(int a[])
	{
		for(int i=1;i<a.length;i++)
		{
			int insertval=a[i];//保存当前即将插入的值
			int index=i-1;    //跟他的前面的值进行比较，记录前面的值的下标
			while(index>=0&&a[index]>insertval) //如果待插入值比前面的小则进入循环
			{
				//进来后前面的值往后移动一位	
				a[index+1]=a[index];
				//然后下标往前移动，在跟前面的比较用不用在继续往前面移动，
 				index--; 			
			}
			a[index+1]=insertval;
                 //1 4 2 3
                 //1 4 4 3  退出while交换inserval后则变为 1 2 4 3
                 //1 2 4 3
                 //1 2 4 4
                 //1 2 3 4
                 //唯一困惑的就是：符合while后前面的值会不断地覆盖后面的值,知道符合条件不覆盖
                   时在用inertval进行交换,注意index要大于等于0的，否则越界了成负的了。
		}
	}
}

5.快速排序

class QuickSort{

public void sort(int a[], int left, int right)
{
    if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
    {
        return ;
    }
    int i = left;
    int j = right;
    int key = a[left];
     
    while(i < j)                               /*控制在当组内寻找一遍*/
    {
        while(i < j && key <= a[j])
        /*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
        序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/ 
        {
            j--;/*向前寻找*/
        }
         
        a[i] = a[j];
        /*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
        a[left]，那么就是给key）*/
         
        while(i < j && key >= a[i])
        /*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
        因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
        {
            i++;
        }
         
        a[j] = a[i];
    }
     
    a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
    sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
    sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
                       /*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}
}