public class ArrayDemo6{
        public static void main(String args[]){
                int[] arr = {1,4,23,0,67,4,78};
                printArray(arr);
                Arraysort(arr);
                printArray(arr);
               
        }
        public static void printArray(int[] arr){
                System.out.print("[");
                for(int i=0;i<arr.length;i++){
                        if(i!=arr.length-1){
                                System.out.print(arr[i]+", ");
                        }
                        else
                                System.out.print(arr[i]+"]");
                }
        }
        public static void Arraysort(int[] arr){
                for(int i=0;i<arr.length-1;i++){        //{1，2，3，4，5，6，9，7，5，4，3}
                        for(int j=i+1;j<arr.length;j++){
                                if(arr[i]<arr[j]){
                                        int temp;
                                        temp = arr[j];
                                        arr[j] = arr[i];
                                        arr[i] = temp;
                                }
                        }
                }
        }
}

建议你掌握冒泡排序和选择排序，可以背写出来，但是一般写代码的时候排序，都用的是Arrays(需要导包)里面的的sort排序方法，它的底层是一个快速排序，原理有点复杂，会用就行，很方便，可以将任意数组排序，比如arr是一个int数组，就可以直接排序:Arrays.sort(arr)，这样就排序完毕了，想看效果，遍历即可。我用的手机回复的 ，不方便写完整的代码，你如果觉得对你有帮助，可以扣1，我上电脑打代码给你

/**  
* 冒泡法排序<br/>  

* <li>比较相邻的元素。如果第一个比第二个大，就交换他们两个。</li>  
* <li>对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。</li>  
* <li>针对所有的元素重复以上的步骤，除了最后一个。</li>  
* <li>持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。</li>  

*   
* @param numbers  
*            需要排序的整型数组  
*/  
public static void bubbleSort(int[] numbers) {   
    int temp; // 记录临时中间值   
    int size = numbers.length; // 数组大小   
    for (int i = 0; i < size - 1; i++) {   
        for (int j = i + 1; j < size; j++) {   
            if (numbers[i] < numbers[j]) { // 交换两数的位置   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
            }   
        }   
    }   
}  

**  
* 选择排序<br/>  
* <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>  
* <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>  
* <li>以此类推，直到所有元素均排序完毕。</li>  

*   
* @param numbers  
*/  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if (numbers[j] < numbers[k])  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}  

这篇博客里面讲的很详细了 http://blog.csdn.net/hguisu/article/details/7776068

1选择排序 *                  int[] arr = {66,55,44,33,22,11};                 原理：如果拿0角标上的元素依次和后面的元素进行比较，                       第一次内循环结束后，最小值出现在了0角标位置。                 arr[0]与arr[1-5]比了五次                 arr[1]与arr[2-5]比了四次                 arr[2]与arr[3-5]比了三次                 arr[3]与arr[4-5]比了二次                 arr[4]与arr[5]比了一次                 你就想想我们是如何打星星                 *****                 ****                 ***                 **                 *                 arr[x]与arr[y]比较                 数组长度是6                 for (int x = 0;x < arr.length - 1;x++){                         for (int y = x + 1;y < arr.length;y++){                                 if (arr[x] > arr[y]){                                         int temp = arr[x];                                         arr[x] = arr[y];                                         arr[y] = temp;                                 }                         }                 }                  * 2冒泡排序                  int[] arr = {66,55,44,33,22,11};                 原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。                 第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4],arr[4]与arr[5],比了五次                 第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比了四次                 第三次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比了三次                 第四次:arr[0]与arr[1],arr[1]与arr[2]比了二次                 第五次:arr[0]与arr[1]比了一次                 for (int x = 0;x < arr.length - 1; x++){                         //-1防止角标越界                         //-x为了提高效率                         for (int y = 0;y < arr.length - 1 - x;y++){//6                                 if (arr[y] > arr[y+1]){                                         int temp = arr[y];                                         arr[y] = arr[y+1];                                         arr[y+1] = temp;                                 }                         }                 } * 3,查找         * A：无序数组         *                                           int[] arr = {33,22,11,44,55,66};                         public static int getIndex(int[] arr,int key) {                                 for (int x = 0;x < arr.length;x++){                                         if (key == arr[x]){                                                 return x;                                         }                                 }                                 return -1;                         }         * B：有序数组 二分查找         *                          数组长度是6,最大角标值是5                         public static int getIndex(int[] arr,int key) {                                 int min = 0;                                 int max = arr.length-1;                                 int mid = (min + max)/2;                                 while (key != arr[mid]){                                         if (key > arr[mid]){                                                 min = mid + 1;                                         }else if (key < arr[mid]){                                                 max = mid - 1;                                         }                                         if (min > max){                                                 return -1;                                         }                                         mid = (min + max)/2;                                 }                                 return mid;                                                          }

学习中。。

还没学到- -   表示不太懂

//选择排序
public static void Demo(int[] arr) {
                for (int x=0;x<arr.length-1 ; x++) {
                        for (int y=x+1;y<arr.length ; y++) {
                                if (arr[x]>arr[y]) {
                                        swap(arr,x,y);
                                }
                        }
                }
        }
//冒泡排序
public static void Demo2(int[] arr){
                for (int x=0;x<arr.length-1 ;x++ ){
                        for (int y=0;y<arr.length-x-1 ;y++ ){
                                if (arr[y]>arr[y+1]) {
                                        swap(arr,y,y+1);
                                }
                        }
                }
        }

学习 学习

不错，又长见识了

import java.util.Scanner;  /*编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）  例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文*/   public class Test10 {       public static void main(String[] args) throws Exception {           // 输入要截取的字符串               Scanner scanner =new Scanner(System.in);                 String a;                 int i;                 System.out.println("请输入一个字符串和截取字节数：");                 a=scanner.nextLine();                                  i=scanner.nextInt();         System.out.println(mySubstring(a,i));       }             public static String mySubstring(String s, int length) throws Exception {           // 获取一个字符占两个字节的Unicode的编码格式的字节数组           byte[] bytes = s.getBytes("Unicode");   /*  String的getBytes()方法是得到一个系统默认的编码格式的字节数组  中文是用unicode进行编码的  于是在接收和发送的时候，都必须进行bytes的转换  */           // 表示当前的字节数           int n = 0;           // 要截取的字节数，从第3个字节开始           int i = 2;           for (; i < bytes.length && n < length; i++) {                     // 奇数位置，如3、5、7等，为UCS2编码中两个字节的第二个字节               if (i % 2 == 1)                   n++; // 在UCS2第二个字节时n加1               else {                   // 当UCS2编码的第一个字节不等于0时，该UCS2字符为汉字，一个汉字算两个字节                   if (bytes[i] != 0) {                       n++;                   }               }           }           // 如果i为奇数时，处理成偶数                 if (i % 2 == 1) {               // 该UCS2字符是汉字时，去掉这个截一半的汉字               if (bytes[i - 1] != 0)                   i = i - 1;               // 该UCS2字符是字母或数字，则保留该字符               else                   i = i + 1;           }           return new String(bytes, 0, i, "Unicode");       }   }  

package com.itheima; /* 请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。         * 我了解的一些排序算法：      * 直接选择排序，冒泡排序，折半排序，快速排序，直接插入排序，希尔排序，归并排序      *       * 这里实现一个效率较高的冒泡排序*/ public class Test4 {                    public static void main(String[] args) {                          int[] str = {2,45,6,87,3,56,1,56};             //打印数组元素             printArray(str);             //对数组进行排序             bubbleSort(str);             printArray(str);                   } //数组打印     public static void printArray(int[] str) {                          System.out.print("[");             for (int i = 0; i < str.length; i++) {                     if(i!=str.length-1)                             System.out.print(str[i]+",");                     else                             System.out.println(str[i]+"]");                                  }     } //冒泡排序     public static void bubbleSort(int[] str) {              for ( int i = 0; i < str.length; i++ )             {                 for ( int j = i + 1; j < str.length; j++ )                 {                     if (str[i] > str[j])                     {                         swap(str, i, j);                     }                 }             }                               } //元素交换位置     public static void swap(int[] str, int i, int j) {             int temp = str[i];             str[i] = str[j];             str[j] = temp;     }  }