1、随机产生一个无重复数的×××数组，对其进行排序，并随机产生一个数插入到此数组中，且保持此数组有序。

import java.util.Arrays;

import java.util.Random;
public class Demo01
{
    private Random rd = new Random(); //产生随机数对象
    private int arr_length = 10; //数组大小
    private int rand = 50; //最大随机数（不包含）
    private int[] arr = null; //随机数组
    private int dir = 0; //要插入数的位置
    private int insNum = 0; //要插入的数


    public static void main(String[] args)
    {
        new Demo01().init();
    }

    private void init()
    {
        arr = randomArr(arr_length,rand);
        System.out.println("随机产生无重复的数组：");
        printArr(arr);

        System.out.println("排序后的数组：");        
        sort(arr);
        printArr(arr);

        insNum = random(rand);
        System.out.println("随机产生插入的数：");
        System.out.println(insNum);

        dir = binarySearch(arr,insNum); //插入的位置

        arr = insertNum(arr,insNum,dir);
        System.out.println("插入后的数组：");
        printArr(arr);
    }

    /**
    * 产生随即数
    * 返回一个整数
    */
    private int random(int num)
    {
        return rd.nextInt(num);
    }    

    /**
    * 产生无重复元素的数组
    * 返回无重复的数组
    */
    private int[] randomArr(int num,int max)
    {
        int[] arr = new int[1];
        boolean flag = true;
        int i = 0;
        while(flag)
        {
            int n = rd.nextInt(max);
            for(int j=0;j<arr.length;j++)
            {
                if(arr[j] == n)
                {
                    flag = false;
                    break;
                }
            }
            if(flag)
            {
                arr = Arrays.copyOf(arr,arr.length+1);
                arr[i++]=n;
                if(arr.length-1 == num)
                {
                    arr = Arrays.copyOf(arr,arr.length-1);
                    flag = false;
                }
            }
            else
            {
                flag = true;
            }
        }
        return arr;
    }

    /**
    * 将指定的数插入到指定位置的数组中
    * 返回插入后的数组
    */
    public int[] insertNum(int[] arr,int num,int wei)
    {
        int[] ary = null;
        ary = Arrays.copyOf(arr,wei);    
        ary = Arrays.copyOf(ary,arr.length+1);
        ary[wei] = num;
        System.arraycopy(arr,wei,ary,wei+1,arr.length-wei);
        return ary;    
    }

    /**
    * 二分查找(折半查找)
    * 返回要插入的位置
    */
    public int binarySearch(int[] arr,int num)
    {
        int min = 0;
        int max = arr.length-1;
        int mid = (min+max)/2;

        while(min <= max)
        {
            if(arr[mid] < num)
                min = mid+1;
            else if(arr[mid] > num)
                max = mid-1;
            else
                return mid;
            mid = (min + max)/2;
        }
        return min;
    }

    //冒泡排序    
    public void sort(int[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr.length-1-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    //打印数组
    public void printArr(int[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

}


2、用户输入一个十进制的数，并输出次数的二进制、八进制和十六进制。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;

public class Demo02
{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private char[] ch = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E'};
    private int num = 0; //用户输入的数


    public static void main(String[] args)
    {
        new Demo02().init();
    }

    private void init()
    {
        num = getUserInput();

        System.out.println(num+"的十六进制：");
        printArr(zh(num,16));
        System.out.println(num+"的八进制：");
        printArr(zh(num,8));
        System.out.println(num+"的二进制：");
        printArr(zh(num,2));
    }


    //输出指定数的指定进制
    private char[] zh(int num,int bin)
    {
        char[] chs = new char[1];
        int n = 0;
        int index = 0;
        switch(bin)
        {
            case 16:
                n = 4;
                break;
            case 8:
                n = 3;
                break;
            case 2:
                n = 1;
                break;
            default:
                n = 1;
                break;
        }

        while(num!=0)
        {
            int a = num & (bin - 1);
            num = num >>> n;
            chs[index++] = ch[a];
            chs = Arrays.copyOf(chs,chs.length+1);
        }
        chs = Arrays.copyOf(chs,chs.length-1);
        chs = reArr(chs);
        return chs;
    }

    //翻转数组
    private char[] reArr(char[] ch)
    {
        char[] chs = new char[ch.length];
        for(int i=0;i<ch.length;i++)
        {
            chs[i] = ch[ch.length-1-i];
        }
        return chs;
    }

    //得到用户输入的转换数字
    private int getUserInput()
    {
        String str = null;
        try
        {
            do
            {
                System.out.println("请输入转换数：");
                str = br.readLine();
            }while(!str.matches("[0-9]+"));
        }
        catch(IOException e)
        {
            System.out.println("输入异常了！");
        }
        return new Integer(str);
    }

    //打印数组
    private void printArr(char[] ch)
    {
        for(int i=0;i<ch.length;i++)
        {
            System.out.print(ch[i]);
        }
        System.out.println();
    }    
}


3、去除数组中重复的数

import java.util.Arrays;

public class Demo03
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{2,5,3,2,5,8,1,2,4,2,5,6,4,4,4,2,3};
        System.out.println("取重复前：");
        printArr(arr);

        arr = removeReplaceArr(arr);

        System.out.println("取重复后：");
        printArr(arr);        
    }

    //去除数组中重复的数
    public static int[] removeReplaceArr(int[] arr)
    {
        int[] arr_temp = {arr[0]};
        boolean flag = true;
        int n = 1;
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr_temp.length;j++)
            {
                if(arr_temp[j] == arr[i])
                {    
                    flag = false;
                    break;
                }
            }
            if(flag)
            {
                arr_temp = Arrays.copyOf(arr_temp,arr_temp.length+1);
                arr_temp[n] = arr[i];
                n++;
            }
            flag = true;
        }
        return arr_temp;
    }

    //打印数组
    public static void printArr(int[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }


4、统计数组中各元素出现的次数

import java.util.Arrays;

public class Demo04
{
    public static void main(String[] args)
    {
        int[] arr = new int[]{2,5,3,2,5,8,1,2,4,2,5,6,4,4,4,2,3};

        replaceNum(arr);
    }

    //统计数组中各元素出现的次数
    public static void replaceNum(int[] arr)
    {
        boolean[] bl = new boolean[arr.length];

        for(int i=0;i<arr.length;i++)
        {
            int sum = 1;
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[i] == arr[j] && !bl[j])
                {
                    sum++;
                    bl[j] = true;
                }
            }
            if(!bl[i])
                System.out.println(arr[i]+":"+sum+"个");
        }
    }

    //打印数组
    public static void printArr(int[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}