java中数组的四种排序

原创已于 2022-09-21 21:35:06 修改 · 3k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #数据结构

于 2022-09-19 20:07:06 首次发布

java 专栏收录该内容

20 篇文章

订阅专栏

本文介绍了Java中的数组基础知识，包括数组的基本概念、声明、内存模式和遍历。重点讲解了排序部分，尤其是冒泡排序的原理和实现过程，帮助读者理解如何在Java中对数组进行升序或降序排列。

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

1.数组

1.1数组的基本概念

数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量/12713827)。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便，把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。
数组是用于储存多个相同类型数据的集合。
在这里插入图片描述

  public static void main(String[] args) {
		double[] ds = new double[3]; 
		ds[2] 
		//String有length方法.length(),Arrays有length属性.length 
		System.out.println(ds.length);//3 
		System.out.println(ds[1]); //0.0 //声明字符串数组，并直接初始化。3个元素 
		String[] ss = new String[]{"java", "hello", "mysql"}; //声明int型的数组，长度为3，并初始化全部数据为0 
		int[] a = new int[3]; // 0 1 2 三个 0 
		a[1] = 100; System.out.println(a[0]);//0 
		System.out.println(a[1]);//100 
		System.out.println(a[2]);//0 //a[3] = 20; 错误的，数组在java长度是固定 
		//下边行是有异常的， 
		System.out.println(a[3]);//数组下标是0 1 2 没有3
	}

1.2 声明数组

在这里插入图片描述

public class Arr1 { 
	public static void main(String[] args) { 
		int[] nums = {1, 2, 3}; 
		System.out.println(nums[2]); 
} 
}

1.3内存模式

在这里插入图片描述

1.4遍历数组

	int[] a = new int[]{1, 20, 300};
	System.out.println(a.length); //数组对象的属性，返回一个int数字，代表当前数组的元素个数
	System.out.println(a[2]);
	     //遍历一
        for(var i : a){   
            System.out.println(i);
        }
         // 遍历二
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        //倒序遍历            
        for (int i = ls.length - 1; i >= 0; i--) {     
            System.out.println(ls[i]);
        }
	        //遍历四 java8 lambda 表达式遍历方式
	       Arrays.stream(a).forEach(System.out::println);

2.排序

2.1乱序，升降序

public class ArrSort3 { 
     public static void main(String[] args) {
          var ss = new String[]{"java", "python", "c", "php", "go", "ruby", "javascript"};  
	     //未排序 
         System.out.println(Arrays.toString(ss)); 
	     //升序 
	     Arrays.sort(ss); 
	     System.out.println(Arrays.toString(ss)); 
	     //降序
	     Arrays.sort(ss, Comparator.reverseOrder());   
	     System.out.println(Arrays.toString(ss));
	     //乱序 
	     Arrays.sort(ss, (a, b) -> Math.random() > .5 ? 1 : -1); 
	     System.out.println(Arrays.toString(ss)); 
       } 
       }

2.2冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

public static void main(String[] args) {
        //01 声明数组
        int[] nums = new int[10];

        //02 数组元素赋值
        Random rand = new Random();
        for (int i = 0; i < nums.length; i++) nums[i] = rand.nextInt(1, 101);

        //03 排序前输出，直接使用Arrays.toString(nums);
        System.out.println("排序前：" + Arrays.toString(nums));

        //04排序算法（冒泡排序）
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1; j++) {
                if (nums[j] < nums[j + 1]) {  // > 换为升序  < 换为降序
                    int a = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = a;
                }
            }
        }

        //05 排序输出
        System.out.println("排升序后：" + Arrays.toString(nums));

       //04排序算法（冒泡排序）
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1; j++) {
                if (nums[j] > nums[j + 1]) {  // > 换为升序  > 换为降序
                    int a = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = a;
                }
            }
        }
        //05 排序输出
        System.out.println("排降序后：" + Arrays.toString(nums));

   }
 }