编写程序把这些IP按数值大小，从小到大排序出来。
61.54.231.245
61.54.231.9
61.54.231.246
61.54.231.48
61.53.231.249

向阳泪无痕 发表于 2013-11-18 10:29
论坛好像不让发QQ吧 给你邮箱吧  你懂得

谢谢，还是原来视频里有讲这个怎么做，没看完不知道，现在看完了，会了用正则表达式，呵呵

Joney__ 发表于 2013-11-15 09:43
代码不错。。。就是看不懂

主要是代码中使用了正则表达式来完成的。。。。如果你把正则表过式搞清楚了  这个代码你看着就简单了。。

Joney__ 发表于 2013-11-16 23:04
哥们方便留个邮箱或者QQ吗？能否给我说说思路，弄不出来都睡不好觉，急死了 ...

论坛好像不让发QQ吧 给你邮箱吧 524077013@qq.com 你懂得

向阳泪无痕 发表于 2013-11-15 09:33
给你一个最简单，代码最少的。

哥们方便留个邮箱或者QQ吗？能否给我说说思路，弄不出来都睡不好觉，急死了

解决了吗

狼王 发表于 2013-11-15 11:33
这是一个入学测试题，尽量自己解决

我哪里有点问题卡住了，来这问问，想弄明白该怎么做，要的是方法，不是代码

这是一个入学测试题，尽量自己解决

rebirth 发表于 2013-11-15 10:05
这个要把ip写成ip类，这是面向对象的万事万物皆对象。你可以用TreeSet写，但是TreeSet用的是红黑树，这个 ...

测试了，输出没有问题，我好好学习下，请问如果按我上面写得那种，这些IP是读取txt的，该怎么改？我转换数组没有数据怎么回事？不能按“.”拆分吗？

Joney__ 发表于 2013-11-15 08:35
实现comparable接口后应该怎么判断？能具体写代码看下码？谢谢。

这个要把ip写成ip类，这是面向对象的万事万物皆对象。你可以用TreeSet写，但是TreeSet用的是红黑树，这个你代码量少了些，但是犯不着用红黑树做。排序算法是基础嘛，少的话自己写一个冒泡，多的时候自己写一个快排。当然你如果不爱写，就和我的代码一样用Arrays.sort()方法，因为你数组不是整型数组所以少的话会调用冒泡，多的话调用归并。我记得没错的话是以7个元素为界限

1. 
   
2. import java.util.*;
   
3. //61.54.231.9
   
4. //61.54.231.48
   
5. //61.54.231.48
   
6. //61.53.231.249
   
7. //61.54.231.245
   
8. //61.54.231.246
   
9. public class Main {
   
10.     public static void main(String[] args){
    
11.         IP[] ips = new IP[6];
    
12.         ips[0] = new IP("61.54.231.9");
    
13.         ips[1] = new IP("61.54.231.48");
    
14.         ips[2] = new IP("61.54.231.48");
    
15.         ips[3] = new IP("61.53.231.249");
    
16.         ips[4] = new IP("61.54.231.245");
    
17.         ips[5] = new IP("61.54.231.246");
    
18.         
    
19. //        Arrays.sort(ips);
    
20. //        for(int i=0; i<ips.length; i++){
    
21. //            System.out.println(ips[i]);
    
22. //        }
    
23. 
    
24.         Set<IP> tm = new TreeSet<IP>();
    
25.         tm.add(ips[0]);
    
26.         tm.add(ips[1]);
    
27.         tm.add(ips[2]);
    
28.         tm.add(ips[3]);
    
29.         tm.add(ips[4]);
    
30.         tm.add(ips[5]);
    
31.         for(IP ip : tm){
    
32.             System.out.println(ip);
    
33.         }
    
34.     }
    
35. }
    
36. class IP implements Comparable<IP>{
    
37.     private String ip;
    
38.    
    
39.     public IP(){}
    
40.     public IP(String str){
    
41.         ip = str;
    
42.     }
    
43.     public int returnValue(){
    
44.         String[] arr = ip.split("\\.");
    
45.         return Integer.parseInt(arr[0])*256*256*256 + Integer.parseInt(arr[1])*256*256 + Integer.parseInt(arr[2])*256 + Integer.parseInt(arr[3]);
    
46.     }
    
47.     public int compareTo(IP ip) {
    
48.         if(this.returnValue() > ip.returnValue() ){
    
49.             return 1;
    
50.         }else{
    
51.             return -1;
    
52.         }
    
53.     }
    
54.     public String toString() {
    
55.         return ip;
    
56.     }
    
57.    
    
58. }
    

复制代码

向阳泪无痕 发表于 2013-11-15 09:33
给你一个最简单，代码最少的。

代码不错。。。就是看不懂

杨增坤 发表于 2013-11-15 00:00
这是自动排序，可是用TreeSet，你也可以分割字符串，但是这有现成的类，那么就方便了。 ...

这个最简洁~~~

给你一个最简单，代码最少的。

1. import java.util.*;
   
2. class  IpText
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 text();
   
7.         }
   
8. 
   
9.         public static void text()
   
10.         {
    
11.                 String ip = "61.54.231.245  61.54.231.9  61.54.231.246  61.54.231.48  61.53.231.249";
    
12.                                
    
13.                 ip = ip.replaceAll("([0-9]+)","00$1");//字符串替换，都补上两个00 ，用正则表达式完成。
    
14.        
    
15.                 ip = ip.replaceAll("0*([0-9]{3})","$1"); //把补多的0去掉，每一个地址段只保留3位数字，如第一个变成 061.054.231.245
    
16.                
    
17.                 String[] arr = ip.split(" +");//切割后存入到数组中
    
18.                
    
19.                 Arrays.sort(arr);//数组快速排序方法，这个方法最简单
    
20. 
    
21.                 //输出数组内容
    
22.                 for(String s : arr)
    
23.                 {
    
24.                         System.out.println(s.replaceAll("0*([0-9]+)","$1"));  //在输出时，顺便把补上的再0去掉
    
25.                 }
    
26.         }
    
27. }

复制代码

1. <p>import java.io.BufferedReader;
   
2. import java.io.FileNotFoundException;
   
3. import java.io.FileReader;
   
4. import java.io.IOException;
   
5. 
   
6. 
   
7. /**
   
8. * 把以下IP存入一个txt文件，编写程序把这些IP按数值大小，
   
9. * 从小到达排序并打印出来。
   
10. * 61.54.231.245
    
11. * 61.54.231.9
    
12. * 61.54.231.246
    
13. * 61.54.231.48
    
14. * 61.53.231.249
    
15. *  1：创建ip.txt文件，在里面写入上面Ip
    
16. *  2：用BuffReader读取IP.txt中的数据
    
17. *  3：把获取的单个字符转换成字符串数组
    
18. *  4：在用“.”进行拆分
    
19. *  5：拆分后进行比较并输出
    
20. *
    
21. */
    
22. public class Test8 {
    
23. 
    
24.         public static void main(String[] args) {
    
25.         
    
26.                 BufferedReader br=null;
    
27.                 try {
    
28.                         br=new BufferedReader(new FileReader("Ip.txt"));
    
29.                         char[] chs = new char[1024];
    
30.                         int len = 0;
    
31.                         while((len = br.read(chs)) != -1){
    
32.                                 //将字符数组转换成字符串数组
    
33.                                 String s3 = String.valueOf(chs);
    
34.                                 //System.out.println(s3);
    
35.                                 String[] strArray = s3.split(".");
    
36.                                 
    
37.                                 for (int x = 0; x < strArray.length; x++) {
    
38.                                         System.out.println(strArray[x]);
    
39.                                 }
    
40.                                 //System.out.print(String.copyValueOf(chs, 0, len));
    
41.                         }
    
42.                 } catch (FileNotFoundException e) {
    
43.                         // TODO Auto-generated catch block
    
44.                         e.printStackTrace();
    
45.                 } catch (IOException e) {
    
46.                         // TODO Auto-generated catch block
    
47.                         e.printStackTrace();
    
48.                 }finally{
    
49.                         try {
    
50.                                 br.close();
    
51.                         } catch (IOException e) {
    
52.                                 // TODO Auto-generated catch block
    
53.                                 e.printStackTrace();
    
54.                         }
    
55.                 }
    
56.         }
    
57. 
    
58. }
    
59. </p>

复制代码

把以下IP存入一个txt文件，编写程序把这些IP按数值大小， 从小到达排序并打印出来。
61.54.231.245
61.54.231.9
61.54.231.246
61.54.231.48
61.53.231.249
这是完整的题目，我参考上面截取方法，写了下面的代码，怎么截取出来的数组是空的？那里错了？

杨增坤 发表于 2013-11-15 00:00
这是自动排序，可是用TreeSet，你也可以分割字符串，但是这有现成的类，那么就方便了。 ...

这样写排序不了的，没有我想要的排序效果，我上面用的就是这种方法，呵呵，还是不行。不过非常谢谢你

rebirth 发表于 2013-11-14 22:05
写一个IP类，实现comparable接口，至于排序，数量少的话用不着TreeMap吧，毕竟TreeMap是红黑树，用这个排序 ...

实现comparable接口后应该怎么判断？能具体写代码看下码？谢谢。

赵晓海 发表于 2013-11-14 21:42
用String类的split分割出数组，然后进行比较，比用treemap简单吧？

刚开始我是想TreeMap不是自带排序功能嘛，如果按类来比较，判断类的属性什么的，这样好写判断，谁知道写判断的时候不好写了，你的意思是写五个数组分别按  .  来截取？然后分别比较每个元素？最后在输出？你能写代码出来吗？我看下，谢谢了。真心不知道该怎么比较

这是自动排序，可是用TreeSet，你也可以分割字符串，但是这有现成的类，那么就方便了。

1. public class Demo {
   
2.         public static void main(String[] agrs) {
   
3.           TreeSet<String> set=new TreeSet<String>();
   
4.           set.add("61.54.231.245");
   
5.           set.add("61.54.231.9");
   
6.           set.add("61.54.231.246");
   
7.           set.add("61.54.231.48");
   
8.           set.add("61.53.231.249");
   
9.          
   
10.           System.out.println(set);
    
11.         }
    
12. 
    
13.        
    
14. }
    

复制代码