精华内容
下载资源
问答
  • java String[]字符串数组自动排序的简单实现 java String[]字符串数组自动排序的简单实现
  • java数组反转排序

    千次阅读 2018-02-03 17:11:16
    package 数组排序算法; public class 反转排序 { public static void main(String[] args) { // TODO 自动生成的方法存根 int [] arr = new int[] {2,4,6,8,10,9,7,5,3,1}; 反转排序.sort(arr); } public...
    package 数组排序算法;
    
    public class 反转排序 {
    
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
    		int [] arr =  new int[] {2,4,6,8,10,9,7,5,3,1};
    		反转排序.sort(arr);
    	}
    	public static void sort(int[] arr) {
    		System.out.println("原一维数组:");
    		反转排序.showarr(arr);
    		for (int i = 0; i <arr.length/2;i++) {
    			arr[i] 				^= 	arr[arr.length-1-i];
    			arr[arr.length-1-i] ^= arr[i];
    			arr[i] 				^= arr[arr.length-1-i];
    		}
    		System.out.println("反转排序后的一维数组:");
    		反转排序.showarr(arr);
    	}
    	public  static void showarr(int[]arr) {
    		for (int tmp:arr) {
    			System.out.print(tmp+"\t");
    		}
    		System.out.println();
    	}
    }
    

    执行结果:


    展开全文
  • //已有一个升序排列的整数数组(含20个整数),要求从键盘输入一个整数后,将该数插入数组,并保持升序,输出该数组的数值验证程序的正确性。packagetest_Array;importjava.util.ArrayList;importjava.util.Arrays;...

    //已有一个升序排列的整数数组(含20个整数),要求从键盘输入一个整数后,将该数插入数组,并保持升序,输出该数组的数值验证程序的正确性。

    package test_Array;

    import java.util.ArrayList;

    import java.util.Arrays;

    import java.util.Collection;

    import java.util.Scanner;

    public class ArrayTest {

    public static void main(String[] args){

    ArrayTest at = new ArrayTest();

    at.sortArray();

    //为了体现Java语言的封装特性,我们将主要的执行方法至于main()方法之外

    }

    Object sortArray(){

    /*

    *这里我们首先创建一个数组并初始化

    *然后讲数组转化为集合后加入从键盘输入的数

    *最后将集合再转化为数组

    *然后调用Arrays.sort()方法在foreach中输出

    *

    */

    int[] array = new int[]{-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9};

    //这里加入泛型机制,是程序安全性更高

    Collection arrayList = new ArrayList();

    System.out.println("Old array‘s length:"+array.length);

    for(int i=0;i

    System.out.print(" "+array[i]);

    arrayList.add(new Integer(array[i]));

    }

    System.out.print("\n"+"Please input a number:");

    arrayList.add(new Integer(input()));

    System.out.println("Current array‘length:"+arrayList.size());

    Object[] now=arrayList.toArray();

    Arrays.sort(now);

    for(Object currentArray:now){

    System.out.print(" "+currentArray);

    }

    return arrayList;

    }

    static int input() {

    int input = (new Scanner(System.in)).nextInt();

    return input;

    }

    }

    展开全文
  • 1、自动排序用到了java.util.Arrays里面的sort方法,导好包直接使用就好。 2、倒序就是将第一个和倒数第一个交换、第二个和倒数第er个交换…以此类推,找到规律就用for循环将他们进行交换就好。 import java.util....
    1、自动排序用到了java.util.Arrays里面的sort方法,导好包直接使用就好。
    2、倒序就是将第一个和倒数第一个交换、第二个和倒数第二个交换…以此类推,找到规律就用for循环将他们进行交换就好。
    import java.util.Arrays;
    
    public class ArraySortText {
    	public static void main(String[] args) {
    		
    		//声明构建初始化数组
    		int[] arr = {5,3,9,4,6,8,2};
    		/*
    		 * 
    		 * 使用java.util.Arrays里面的sort方法
    		 * 对数组arr进行升序排列(这个方法只能升序排列)
    		 *
    		 */
    		Arrays.sort(arr);
    		
    		//遍历自动排序数组
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i]+" ");
    		}
    		System.out.println();
    		
    		//对排列好的数组进行倒序(从大排到小)
    		for (int i = 0; i < arr.length/2; i++) {
    			int x = arr[i];
    			arr[i] = arr[arr.length-i-1];
    			arr[arr.length-i-1] = x;
    		}
    		//对倒序好的数组进行遍历
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i]+" ");
    		}
    		System.out.println();
    	}
    }
    /*
     * 结果:
     * 2 3 4 5 6 8 9 
     * 9 8 6 5 4 3 2 
     */
    
    

    倒序的第二种做法:

    		//倒序的第二种做法
    		for (int start = 0,end = arr.length-1;start <= end; start++,end--) {
    			int x = arr[start];
    			arr[start] = arr[end];
    			arr[end] = x;
    		}
    
    展开全文
  • 作为java语言的使用者,我们应该都知道java自动封装了Array的工具类,其中我们可能常用的Sort排序方法到底是调用了哪个排序方法呢? JDK8中Arrays.sort的底层原理,调用的是插入排序,归并排序和快速排序。简单来说...

    作为java语言的使用者,我们应该都知道java自动封装了Array的工具类,其中我们可能常用的Sort排序方法到底是调用了哪个排序方法呢?
    JDK8中Arrays.sort的底层原理,调用的是插入排序,归并排序和快速排序。简单来说就是根据数组长度的大小选择合适排序方法。

    元素少于47用插入排序

    元素大于等于47小于286的用快速排序

    至于大于286的,它会进入归并排序(Merge Sort),但在此之前,它有个小动作(就是看数据具不具备结构)

    结构简单来说也就是局部有序。
    在这里插入图片描述

    下面是测试算法

    public class ArraySorts {
    
        /**
         * 不带参数的快速排序
         * @param arr
         */
        public static  void  quickSort(int[] arr){
            int start = 0;
            int end  = arr.length-1;
            quickSortHelp(arr,start,end);
    
        }
        /*
            调用快速排序
         */
        public static  void  quickSortHelp(int[] arr,int start,int end) {
            if(start<end){
                int middle = quickHelp(start,end,arr);
                quickSortHelp(arr,middle+1,end);
                quickSortHelp(arr,start,middle-1);
            }
        }
    
        /**
         *
         * @param start
         * @param end
         * @param arr
         * @return 第一个元素应该在的位置
         */
        public static int  quickHelp(int start,int end, int[] arr){
    
            int temp = arr[start];
            while (start<end){
    
                while (arr[end]>temp&&start<end){
                    end--;
                }
                //从尾部找到比temp小的值  然后换到前面
                arr[start] = arr[end];
    
                while (arr[start]<temp&&start<end){
                    start++;
                }
                //同理
                arr[end] = arr[start];
            }
            //放置temp
            arr[start] = temp;
            //返回位置索引
            return start;
        }
    
        /**
         * 插入排序
         * @param arr
         */
        public static void insertSort(int arr[])
        {
            //数组的长度为1 直接返回
            if(arr.length<=1){
                return;
            }
            else {
                //记录保存插入的值
                int temp;
                for (int i = 1; i <arr.length ; i++) {
                    //记录插入的值
                    temp = arr[i];
                    while (i>0&&arr[i-1]>temp) {
                        arr[i] = arr[i-1];
                        i--;
                    }
                    arr[i] = temp;
                }
            }
    
    
        }
    
    
        /**
         * 合并有序数组
         * @param arr1
         * @param arr2
         * @return
         */
        public static int[] mergeArray(int[]arr1,int[] arr2){
            //申请一个新数组
            int[] arr3 = new int[arr1.length+arr2.length];
            int flag1 = 0;
            int flag2 = 0;
            int flag3 = 0;
            while (flag1<arr1.length&&flag2<arr2.length){
                if(arr1[flag1]<arr2[flag2]){
                    arr3[flag3] = arr1[flag1];
                    flag1++;
                }
                else {
                    arr3[flag3] = arr2[flag2];
                    flag2++;
                }
                flag3++;
            }
            //数组1 元素结束
            if(flag1>=arr1.length){
                for (int i = flag2; i <arr2.length ; i++) {
                    arr3[flag3] = arr2 [i];
                    flag3++;
                }
            }else {
                for (int i = flag1; i <arr1.length ; i++) {
                    arr3[flag3] = arr1 [i];
                    flag3++;
                }
            }
            return arr3;
        }
    
        //数组的压缩
        /**
         * 二维数组
         * @param arr
         * @return
         */
        public static int [][] twoArray(int[][] arr){
            int[][] result;
            //判断arr的长度
            if(arr.length%2 ==0){
                result = new int[arr.length/2][];
            }else {
                result = new int[arr.length/2+1][];
            }
            for (int i = 0; i <result.length ; i++) {
                if( (i * 2 + 1) >= arr.length ) {
                    result[i] = mergeArray(arr[i*2],new int[] {});
                }else {
                    result[i] = mergeArray(arr[i*2],arr[i*2 + 1]);
                }
            }
            return result;
        }
    
        //调用返回
        public static int[] mergeArray(int[] arr){
    
            int [][]arrx = new int[arr.length][1];
    
            /**
             * 将数组分成子数组,每一个子数组内有一个数,所以都是有序的
             */
    
            for(int i=0;i<arr.length;i++)
            {
                arrx[i] = new int[]{arr[i]};
            }
    
            int arry[][] = arrx;
            while (arry.length>1){
                arry = twoArray(arry);
            }
    
            return arry[0];
    
        }
    
    }
    
    展开全文
  • 我有一个父类对象数组 Shape[] shapes=new Shape[10];...这个父类里面存有10个子类,但是我要调用Arrays.sort()这个方法排序对象数组里面的面积怎么弄?? Arrays.sort(shapes) 貌似直接这样不可以额 求高手
  • java String[]字符串数组自动排序

    万次阅读 2013-05-13 13:48:22
    import java.util.Arrays; public class xulie {  /**  * @param args  */  public static void main(String[] args) {  // TODO Auto-generated method stub    String []str = {"abc","bca","cab",...
  • java 数组 直接选择排序 例如:对数组 a[]={12,34,2,1,43,67}分别进行升序和降序排列 public class Arrays { public static void main(String[] args) { // TODO 自动生成的方法存根 int a[] ={12,34,...
  • java数组排序

    2020-10-08 17:16:38
    通过Arrays类的静态sort()方法可以实现对数组排序。sort)方法提供了多种重载形式,可对任意类型的数组进行升序排序。 语法如下: Arrays.sort(object) 其中,object是指进行排序数组名称。 案例: package test...
  • 第一部分:数组 数组是指一组数据的集合,数组中的每个数据称为元素。 ...1,为了数组中每个数据的存取方法特意给数组的每个元素分配下标(自动分配) 2,数组的下标是从 0 开始 3,数组想下标一定...
  • 可以自动数组中的元素从0开始编号,方便操作这些元素 格式1: 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例:int[] arr=new int[5]; 格式2: 元素类型[] 数组名 = new 元素类型[]{元素,元素,...}...
  • 目标:Java中声明排序接口,将数组Java传送到c,c排序后返回。通过替换dll切换排序方法。主要步骤:新建Java类,声明Native接口;自动生成JNI规范的对应C文件格式并实现;Java中加载C编译的dll,调用C的实现;1 ...
  • 昨日回顾 创建数组格式1:元素类型[] 数组名 = new 元素类型[元素个数]; 不明确元素的具体值 元素有默认值 int[] arr1 = new int[10]; ...方式2的简写方式 编译器在编译时期会自动补全 缺点:
  • Java 数组排序算法 :冒泡排序 例如:对数组 a[]={23,3,45,12,34,4,5,78}分别进行升序和降序排列 public class Arrays { public static void main(String[] args) { // TODO 自动生成的方法存根 int a[]...
  • 世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合有人想有可以自动扩展的数组,所以有了List有的人想有没有重复的数组,所以有了set有人想有自动排序的组数,所以有了TreeSet,TreeList,Tree**而几乎有有...
  • 默认情况下 ,保存在List集合中的数组是不进行排序的,不过可以通过使用Comparable接口自定义排序规则并自动排序。本实例将介绍如何使用Comparable接口自定义排序规则并自动排序。 实现过程 1)新建项目...
  • Java数组的运用

    2017-04-16 23:16:00
    Java数组  应用1:  大乐透彩票模拟器: 规则: 前区01-35中随机生成5个号码 后区01-12中随机生成2个号码  模拟操作,系统自动生成号码组合,并且按从小到大的顺序输出结果  同时要求可以选择...
  • 可以自动数组中的元素从0开始编号,方便操作这些元素 数组的声明格式 格式1:元素类型[] 数组名 = new 元素类型[元素个数或者数组长度] 1 2 int[] arr = new int[5]; //定义一个长度为5,...
  • 珍惜当下数据集处理是每种语言必备的功能,Java更甚之,数据集可以允许重复,也可以不允许重复,可以允许 null 存在,也可以不允许 null 存在,可以自动排序,也可以不自动排序,可以是阻塞式的,也可以是非阻塞式的...
  • Java数组中常见算法

    2021-02-21 21:07:27
    文章目录系列文章目录数组元素的赋值:杨辉三角回形数数值类型的计算:求和最大值、最小值平均值数组的复制:数组的反转:数组的查找:线性查找:二分查找:数组元素的排序:冒泡排序 O(n²):快速排序O(log2n): ...
  • 文章目录第1章 数组冒泡排序和Arrays工具类1.1 数组的冒泡排序1.2 Arrays工具类第2章 包装类2.1 基本类型包装类的概述2.2 Integer类的概述和构造方法2.3 int类型和String类型的相互转换2.4 JDK5的新特性自动装箱和...
  • 数组是一种很常见的数据结构,开始接触编程的时候多数程序都和数组相关。刚开始接触Java时也是一直使用数组写一些程序,后来越来越觉得数组这东西...不知道具体数据长度需要自动排序存储键值对当然,上面的情况不...
  • Java数组实例--自动排序

    千次阅读 2017-02-24 15:37:04
    内存分析:局部变量在栈中占一块内存,需先声明(不同的变量类型分配不同的长度,决定程序运行中占内存的大小),再赋值,才能使用,出了作用域自动释放空间。将k和temp放在for循环外面声明,减少了重复分配空间的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 533
精华内容 213
关键字:

java数组自动排序

java 订阅