数组中插入新元素,然后按从小到大排序，想来很久  做不出来  求大牛们给个代码，并附上注释   非常感激啊  

用数组容器Collections.sort(); 方法排序.

或者自己写一个冒泡排序
.

1. public class test4 {
   
2.     public static void main(String[] args) {
   
3.                 int[]arr={4,3,2,1};
   
4.                 int k=1;
   
5.                 int num=0;
   
6.                 int len=arr.length;
   
7.                 System.out.println(Arrays.toString(arr));
   
8.                 for(int i=0;i<len-1;i++){
   
9. 
   
10.            for(int j=i+1;j<len;j++){
    
11.                   num++;
    
12.                    if(arr[i]>arr[j]){
    
13.                            int temp=arr[i];
    
14.                            arr[i]=arr[j];
    
15.                            arr[j]=temp;
    
16.                            System.out.println("第"+k++ +"次排序"+"a["+i+"]"   + "与"+"a["+j+"]" +"调换位置");
    
17.                            System.out.println(Arrays.toString(arr));
    
18.                    }
    
19.            }
    
20.            
    
21.                 }
    
22.                 System.out.println(Arrays.toString(arr));
    
23.                 System.out.println(" 共排序"+num+"次");
    
24.         }
    
25. }
    

复制代码

一个数组在new的时候长度已经指定了,不能修改的.所以你要实现数据的插入,必须扩容.一个实现了自动扩容的Object[] ,其实就是一个ArrayList了.

必须要要使用集合里面的知识了！里面几个容器 arraylist
和 arrayset中都会涉及到对元素的增加删除排序等操作！建议你看看先！

用Collection.sort()方法
需要你实现Comparable接口 并重写compareTo()方法

一楼的不错 - -

蹭点分~~

/*
纯过程实现的~~ ！ 不知道有没有bug!
好像有点长！ ~~ 没学好！ 只能写这么长了~~
*/
import java.util.*;
class A
{
        public static void main(String[] args)
        {
                int j;//数组长度
                //int len=0;
                int tv;//插入的值
                int position;//插入位置
               
                Scanner sc = new Scanner(System.in);
                System.out.printf("请输入数组长度！\n");
                j = sc.nextInt();
                int[] arr = new int[j];
                System.out.printf("请输入数值！\n");
               
                //初始化~
                for(int i=0; i<arr.length; ++i)
                {

                        arr[i] = sc.nextInt();
                }
               
               
                printf(arr);//输出函数
               
                System.out.printf("请输入要插入的值:\n");
                tv = sc.nextInt();
                System.out.printf("\n");
                System.out.printf("请输入要插入位置的下标:");
                position = sc.nextInt();
               
                //判断数组空间
                if(position>arr.length)
                {
                        System.out.printf("位置错误！\n");
                        System.exit(0);
                }
               
                lnsert(arr, tv, position, j);//插入函数
       
        }
       
        //遍历数组
        static void printf(int arr[])
        {
                for(int j=0; j<arr.length; ++j)
                {
                        System.out.printf("  %d", arr[j]);
                }
                System.out.printf("\n");
        }
       
        //插入数值
        static void lnsert(int arr[], int tv, int position, int len)
        {
                int[] buf = new int[len+1];
                int k = buf.length-1;
               
                for(int i=0; i<buf.length-1; ++i)
                {
                        buf[i] = arr[i];
                }
               
                for(int j=buf.length-2; j>=-1; --j)
                {
                        if(j<position)
                        {
                                buf[k] = tv;
                                break;
                        }
                        buf[k] = buf[j];
                        --k;       
                }
                printf(buf);
                System.out.printf("插入成功！\n");
                Sorting(buf, 0, buf.length-1);
                printf(buf);
        }
       
        //下面两个函数是排序！
        static void Sorting(int buf[], int low, int hihg)
        {
                int pos;
                if(low<hihg)
                {
                        //递归
                        pos = Fast(buf, low, hihg);
                        Sorting(buf, pos+1, hihg);
                        Sorting(buf, low, pos-1);
                }
        }
       
        static int Fast(int buf[], int low, int hihg)
        {
                int val = buf[low];
                while(low<hihg)
                {
                        while(low<hihg && buf[hihg]>=val)
                                --hihg;
                        buf[low] = buf[hihg];
                        while(low<hihg && buf[low]<=val)
                                ++low;
                        buf[hihg] = buf[low];
                }
                buf[low] = val;
                return low;
        }
}

梁小刀11 发表于 2015-1-30 23:47
用数组容器Collections.sort(); 方法排序.

或者自己写一个冒泡排序

enen, 谢谢

import java.util.TreeSet;

public class Insert {

        /**
         * @param args
         */
        public static void main(String[] args) {
                /*
                 *需求：数组中插入新元素,然后按从小到大排序
                 *
                 *思路分析：
                 *数组是固定长度的，要插入新的元素，那么需要一个新的容器来装。根据题目要求，
                 *我们知道该容器应具备两点：
                 *1，长度（大小）可变；
                 *2，可排序；
                 *因此，我选择TreeSet来实现。
                 *
                 *步骤：
                 *1，创建TreeSet实例
                 *2，把数组中元素移植TreeSet的容器中；
                 *3，添加新的元素；
                 *4，打印查看结果。
                 *
                 *
                 * */
                int[] ints={11,22,9,30,25,9};
                //1,创建TreeSet实例
                TreeSet<Integer> ts=new TreeSet<Integer>();
                //2，把数组中元素移植ts容器中；
                for(Integer i:ints)
                {
                        ts.add(i);//在对数组遍历过程中，将元素添加进集合ts
                       
                }
                //3,添加新的元素；就比如：10吧
                ts.add(10);
                //4,打印查看结果。
                for(int i:ts)
                {
                        System.out.println(i);       
                }
        }

}

路过  学习学习

看起来好高端的样子，不管了，先保存个书签先，

数组一旦被创建，其长度就已经固定，不能往里面插入新元素，只能将某个位置的元素替换为新元素。如果想要实现插入新元素的操作，需要用到集合框架。排序的方法老毕的视频里有，也可以搜索找到。

数组是不能插入元素的，因为声明是长度就已经固定了，建议使用集合。