Java数组的一些基础小知识

最新推荐文章于 2022-01-25 11:24:41 发布

外面下雨了12138

最新推荐文章于 2022-01-25 11:24:41 发布

阅读量176

点赞数

文章标签： Java

关于Java门基础数组三种排序知识的一点小理解

什么叫数组
是一个存储相同数据类型的一组数据的空间,本身就是一个变量，
数组的四要素：
1.标识符：数组的名字
2.数组元素：存放在数组的每一个数据
3.元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以使用元素下标来访问，即是数组中每个空间的编号
4.元素类型：数组元素的数据类型

：

使用数组
1.声明数组数组的类型数组名；
int arr;
2.定义数组数组名 = new 数据类型[长度]
arr = new int[4]
这样才把内存中开出一个空间，这个空间和连续而且相近的小房间一样
3.逐个赋值数组名 [下标] = 值
arr[0] = 1;
arr[1] = 2;
arr[3] = 3;
arr[4] = 4;
4.使用（例如查询）
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
}
数组特性：
特点：
1.本身就是一个变量
2.数组是用来保存大批量同类数据的一个空间
3.数组的每个空间在内存中一定是连续的
4.数组中的每个数组元素类型必定是相同的

数组的默认值：
每种类型的数组都是有默认值的
int[] arr; 0
arr = new int[4];默认每个下标对应空间放入0：
数组默认值
int[] 0
double[] 0.0
String[] null
char[] \u000
Boolean[] false

三合一
常用的生活中是不是觉得数组的定义是不是过长过于麻烦其实他是可合体的
int[] arr;
arr = new int[4]；
arr[0]=0;
arr[1]=1;
arr[2]=2;
arr[3]=3;
等同于
int[] arr = new int[4];
arr[0]=0;
arr[1]=1;
arr[2]=2;
arr[3]=3;
等同于
int[] arr = {0,1,2,3};
根据不同的使用场景可以实行转换这三种情况

数组的排序
数组的一些基础排序方法冒泡排序，选择排序，插入排序
冒泡排序：依次比较两个相邻的数组元素，将小的元素放在前面，大的元素放在后面。
对于有n个元素的数组需要进行n-1趟比较才能完成整个排序过程。在第1趟，首先比较第1个和第2个元素，将小的放前，大的放后；然后比较第2个和第3个元素，再次将小的放前，大的放
后；如此继续，直至比较最后两个元素，仍然将小的放在前，大
的放后；至此第1趟结束，将最大的元素移动到元素的最后，然
后重复n-1趟如此，直至最后完成从小到大的排序
//冒泡排序

```
	public class BubbleSort{
		public static void main(String []args){
			int[] a = {78,35,23,12,1};
			for(int i=1;i<a.length;i++){ 
				System.out.print(a[i]+"\t");
			} 
			System.out.println("\n第一次交换后：");
			for(int j=0;j<a.length-1;j++){//第一次交换；将最大的值丢向最后				一个元素
 				if(a[j]>a[j+1]){
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1}=temp;
				}        
			}
			for(int i=0;i<a.length;i++){
				System.out.print(a[j]+"\t");
 			}
			System.out.println("\n第二次交换后：");
			for(int j=0;j<a.length-2;j++){//第二次交换；将最二大的值丢向				倒数第二个元素
    				if(a[j]>a[j+1]){
 					int temp=a[j];
      					a[j]=a[j+1];
      					a[j+1}=temp;
   	 			}        
  			}
  			for(int i=0;i<a.lrngth;i++){
				System.out.print(a[j]+"\t");
			}
  			System.out.println("\n第三次交换后：");
  			for(int i=0;j<a.length-3;j++){//第三次交换；将最
  			三大的值丢向倒数第三个元素
   				if(a[j]>a[j+1]){
    					int temp=a[j];
    					a[j]=a[j+];
    					a[j+1]=temp;
   				}
  			}
  			for(int i=0;i<a.lrngth;i++){
    				System.out.print(a[j]+"\t");
  			}
			System.out.print("\n第四次交换后：");
			for(int j=0;j<a.length-4;i++){//第四轮交换；将最
			四大的值丢向倒数第四个元素
				if(a[j]>a[j+1]){
						int temp=a[j];
						a[j]=a[j+1];
						a[j+1]=temp;
				}
			}
			for(int i=0;i<a.length;i++){
				System.out.print(a[i]+"\t");
			}
		}
}
```
由上面的代码可以看出有很多地方是重复相似的部分，这样写显
得过于繁琐，所以重复部分我们采用循环部分来改进，如下

	```
	public class BubbleSort{
		public static void main(String []args){
			for(int i=0;i<a.length-1;i++){
				for(int j=0;j<a.length-1-i;j++){
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
			for(int i=0;i<a.length;i++){
				System.out.print(a[j]+"\t");
			}
		}
	}
	```

选择排序
让数组中的每一个数，依次与后面的数进行比较，如果前面的数大于后面的数，就进行位置的交换。这种说法或许有些人看不明白。换个说法，选择排序：第一个数依次与
后面的数比较，第一次比较完之后最小的数在最前面。依次类推
后数组就按照从小到大的顺序排好了

	```
	public void SelectionSort{
		public static void main(String []args){
			//第一次拿a[0]和接下来的每一个元素比较，然后将最小的
			那个元素放在a[0]的位置
			for(int i=1;i<a.length;i++){
				if(a[0]>a[i]){
					int temp=a[0];
					a[0]=a[i];
					a[i]=temp;
				}
			}
			for(int i=0;i<a.length;i++){
				System.out.print(a[i]+"\t");
			}
			//经过第一次比较之后，最小的元素已经放在了a[0]的位置
			，那么a[0]就可以不用考虑了，接下来将a[1]与剩下来的每
			个元素比较，将第二小的值放在a[1]的位置
			for(int i=2;i<a.length;i++){
				 if(a[1]>a[i]){
						int temp=a[1];
 						a[1]=a[i];
						a[i]=temp;
					}
			}
			System.out.println();
			for(int i=0;i<a.length;i++){
				System.out.print(a[i]+"\t");
			}
			//经过第二次比较之后，第二小的值已经放在a[1]的位置，
			那么就拿a[2]的元素与接下来的元素比较，将第三小的值
			放在a[2]的位置
			for(int i=3;i<a.length;i++){
				if(a[2]>a[i]){
					int temp=a[2];
					a[2]=a[i];
					a[i]=temp;
				}
			}
			System.out.println();
			for(int i=0;i<a.length;i++){
				System.out.print(a[i]);
			}
			//经过第三次比较之后，第三小的值已经放在了a[2]的位置
			那么就拿a[3]的元素与接下来的元素比较，将第四小的值
			放在a[3]位置；
			for(int i=4;i<a.length;i++){
				if(a[3]>a[i]){
				int temp=a[3];
				a[3]=a[i];
				a[i]=temp;
				}
			}
			System.out.println();
			for(int i=0;i<a.length;i++){
			System.out.print(a[i]+"\t");
			}
		}
	}
	```

从上面的代码可以看到很多重复的代码部分，那么可以用循环来解决
如下：

public class SelectionSort{
	public static void main(String []args){
		for(int i=0;i<a.length;i++){
			for(int j=i+1;j<a.length-1;j++){
				if(a[i]>a[j]){
					int temp=a[i];
					a[i]=a[j];
					a[j]=temp; 
				}
			}
		}
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]);
		}
	}
}

插入排序
假定插入的前面部分是有序的，然后用一个数插入其中，与之一一比
较，找到合适的位置插入，使得插入的数组一样有序，重复插入比较
多次，使得整个数组都有序。
如下代码，内循环用于将一个值插入到合适的位置，外循环表示执行的次数

	```
	public class InsertionSort{
		public static void main(String []args){
		int[] a={78,35,23,12,1};
			for(int i=1;i<a.length;i++){//比较轮数
				for(int j=i;j>0;j--){//内层负责比较次数
					if(a[j]<a[j-1]){//比较替换
						int temp=a[j];
						a[j]=a[j-1];
						a[j-1]=temp;
					}
				}
			}
			for(int i=0;i<a.length;i++){
				System.out.print(a[i]+"\t");	
			}
		}
	}
	```

外面下雨了12138

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java数组的一些基础小知识

关于Java门基础数组三种排序知识的一点小理解什么叫数组是一个存储相同数据类型的一组数据的空间,本身就是一个变量，数组的四要素：1.标识符：数组的名字2.数组元素：存放在数组的每一个数据3.元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以使用元素下标来访问，即是数组中每个空间的编号4.元素类型：数组元素的数据类型：使用数组1.声明数组数组的类型数...
复制链接

扫一扫