1. class  t6
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={1,2,0,6,98,0};
   
6.                 //toBin(60);toHex(60);toHex_2(60);
   
7.                 toHex_3(60);
   
8.                 toHex_4(60);
   
9.                 //printArr(arr);
   
10.                 System.out.println("Hello World!");
    
11.         }
    
12.         //打印数组
    
13.         public static void printArr(int[] arr)
    
14.         {
    
15.                 System.out.print("[");
    
16.                 for (int i=0; i<arr.length ;i++ )
    
17.                 {
    
18.                         if (i!=arr.length-1)
    
19.                                 System.out.print(arr[i]+",");
    
20.                         else
    
21.                                 System.out.println(arr[i]+"]");
    
22.                
    
23.                 }
    
24.         }
    
25.         //冒泡排序
    
26.         public static void bubble(int[] arr)
    
27.         {
    
28.                 for (int i=0;i<arr.length-1;i++)
    
29.                 {
    
30.                         for (int j=i+1; j<arr.length ;j++ )
    
31.                         {
    
32.                                 if (arr[i]<arr[j])
    
33.                                 {
    
34.                                         //int temp=arr[i];
    
35.                                         //arr[i]=arr[j];
    
36.                                         //arr[j]=temp;
    
37.                                         swap(arr,i,j);
    
38.                                 }       
    
39.                         }
    
40.                 }
    
41.         }
    
42.         //俩数换值
    
43.         public static void swap(int[]arr,int a,int b)
    
44.         {
    
45.                 int temp=arr[a];
    
46.                 arr[a]=arr[b];
    
47.                 arr[b]=temp;
    
48. 
    
49.         }
    
50.         //数组的查找
    
51.         public static int GetIndex(int[] arr,int key)
    
52.         {
    
53.                 for (int i=0;i<arr.length ;i++ )
    
54.                 {
    
55.                         if (arr[i]==key)
    
56.                                 return i;
    
57.                 }
    
58.                 return -1;//不在该数组内
    
59.         }
    
60.         //折半查找(可以提高效率):数组必须为有序数组，找到的为元素在数组中的角标。
    
61.         public static int halfSearch(int[] arr,int key)
    
62.         {
    
63.                 int min=0,max=arr.length-1,mid=(min+max)/2;
    
64.                 while (arr[mid]!=key)
    
65.                 {
    
66.                         if (key>arr[mid])
    
67.                                 min=mid+1;
    
68.                         else
    
69.                                 max=mid-1;
    
70.                         if(max<min)
    
71.                                 return -1;
    
72.                         mid=(min+max)>>1;
    
73.                 }
    
74.                 return mid;
    
75.         }
    
76.         //折半查找的第二种方式，数组必须为有序的。
    
77.         public static int halfSearch_2(int[] arr,int key)
    
78.         {
    
79.                 int min=0,max=arr.length-1,mid;
    
80.                 while (min<=max)
    
81.                 {
    
82.                         mid=(min+max)/2;
    
83.                         if (key>arr[mid])
    
84.                                 min=mid+1;
    
85.                         else if(key<arr[mid])
    
86.                                 max=mid-1;
    
87.                         else
    
88.                                 return mid;
    
89.                        
    
90.                 }
    
91.                 return -1;//返回-1是表示该数没有找到，返回mid表示该数若存在则应该所在的位置。
    
92.         }
    
93.         //在有序数组中插入一个数，先查找该数组中是否存在该数，若存在，则在其原位插入，
    
94.         //将原来的数据一次往后顺延；若不存在，则返回该数可以插入的位置，然后以此往后顺延。
    
95.         //进制的转换操作
    
96.         //十进制转二进制
    
97.         public static void toBin(int num)
    
98.         {
    
99.                 StringBuffer sb = new StringBuffer();//是一个容器
    
100.                 while (num!=0)
     
101.                 {
     
102.                         sb.append(num%2);
     
103.                         num/=2;
     
104.                 }
     
105.                 System.out.println(sb.reverse());//可以反转输出
     
106.         }
     
107.         //十进制转十六进制
     
108.         public static void toHex(int num)
     
109.         {
     
110.                 for (int x=0;x<8 ;x++ )
     
111.                 {
     
112.                         int temp=num&15;
     
113.                         if(temp>9)
     
114.                                 System.out.println((char)(temp-10+'A'));
     
115.                         else
     
116.                                 System.out.println(temp);
     
117.                         num=num>>>4;
     
118.                 }
     
119.         }
     
120.         public static void toHex_2(int num)
     
121.         {
     
122.                 StringBuffer sb = new StringBuffer();
     
123.                 for (int x=0;x<8 ;x++ )
     
124.                 {
     
125.                         int temp=num&15;
     
126.                         if(temp>9)
     
127.                                 sb.append((char)(temp-10+'A'));
     
128.                         else
     
129.                                 sb.append(temp);
     
130.                         num=num>>>4;
     
131.                 }
     
132.                 System.out.println(sb.reverse());
     
133. 
     
134.         }
     
135.         //查表法来获取内容
     
136.         //将所有的元素临时存储起来，建立对应关系。
     
137.         //每一次&15后的值作为索引去查建立好的表，就可以找到对应的元素，这样比“-10+‘A’简单的多”。
     
138.         public static void toHex_3(int num)
     
139.         {
     
140.                 //建立表
     
141.                 char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
     
142.                 for (int x=0;x<8 ;x++ )
     
143.                 {
     
144.                         int temp=num&15;
     
145.                         System.out.print(chs[temp]);
     
146.                         num=num>>>4;
     
147.                 }
     
148.         }
     
149.         //上面结果是出来了，但是是反着的，要求正向输出。
     
150. 
     
151.         public static void toHex_4(int num)
     
152.         {
     
153.                 char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
     
154.                 char[] arr=new char[8];
     
155.                 int pos=arr.length-1;//倒着存贮
     
156.                 while (num!=0)
     
157.                 {
     
158.                         int temp=num&15;
     
159.                         arr[--pos]=chs[temp];
     
160.                         num=num>>>4;
     
161.                 }
     
162.                 System.out.println(pos);
     
163.                 for (int x=pos;x<arr.length ;x++ )
     
164.                 {
     
165.                         System.out.print(arr[x]+",");
     
166.                 }
     
167.         }
     
168. 
     
169. 
     
170. }
     

复制代码

就这么几个简单的程序，跟着老师敲，还老是编译不通过，不停的找错，改错，太马虎，太粗心

有没有高效一点的法子，我也受不了自己的速度，，与马虎了

自学的c都被我忘掉了，昨天写个循环都忘记怎么输出了。看来语言真是不学就会忘掉那

还是要常常多复习，多巩固，才能越来越好哈。

就我一个人在评论，算是打酱油吗

:loveliness:

小强同学你好~
学习本来就应该是个慢功夫，不要心急
实力总是会在不经意间提高的!

另外不要这样水贴，小心涛哥抓你！:D

你是来蹭经验的么，一，刚学的时候都这样，没基础的语法都记不熟，还有拼写错误能不报错么。
二，你学的时候算法一定要闹清。
少年慢慢来吧，多敲代码，熟能生巧

这样的贴就算水贴啊？记住了哈哈！！！！:lol

努力，哥们