1. 
   
2. import java.io.BufferedWriter;
   
3. import java.io.FileWriter;
   
4. import java.io.IOException;
   
5. import java.util.Arrays;
   
6. 
   
7. /**
   
8. * 3. 把以下IP存入一个txt文件,编写程序把这些IP按数值大小,从小到达排序并打印出来
   
9. *    61.54.231.245
   
10. *    61.54.231.9
    
11. *    61.54.231.246
    
12. *    61.54.231.48
    
13. *    61.53.231.249
    
14. */
    
15. public class IpSort {
    
16.         String[] str1;
    
17.         public static void main(String[] args) {
    
18.                 // 创建类对象
    
19.                 IpSortTest ipst = new IpSortTest();
    
20.                 // 调用类方法
    
21.                 ipst.IpSortDemo();
    
22.                 ipst.writerDemo();
    
23.         }
    
24. }
    
25. class IpSortTest {
    
26.         // 将IP写入IP.txt文件
    
27.         String str = "61.54.231.245 61.54.231.9 61.54.231.246 61.54.231.48 61.53.231.249";
    
28. 
    
29.         public void IpSortDemo() {
    
30.                 // 声明StringBuffer容器
    
31.                 StringBuffer sb = new StringBuffer();
    
32.                 // 将由IP地址组成的字符串加上空格标记存入到str中
    
33.                 String s4 = null;
    
34.                 // 根据空格分割字符串
    
35.                 String[] s = str.split(" ");
    
36.                 // 遍历字符串数组
    
37.                 for (String string : s) {
    
38.                         String s1 = string;
    
39.                         String s2;
    
40.                         // 切割每个IP最后一个点后的字符
    
41.                         s2 = s1.substring(s1.lastIndexOf(".") + 1);
    
42.                         // System.out.println(s1);
    
43.                         // 切割每个IP最后一个之前的字符
    
44.                         String s3 = s1.substring(0, s1.lastIndexOf(".") - 1);
    
45.                         // System.out.println(s3);
    
46.                         // 判断切割出来的字符串，在其前补零
    
47.                         if (s2.length() == 2) {
    
48.                                 s2 = "0" + s2;
    
49.                                 // System.out.println(s1);
    
50.                         } else if (s2.length() == 1) {
    
51.                                 s2 = "00" + s2;
    
52.                                 // System.out.println(s1);
    
53.                         }
    
54.                         // 将字符串前后拼接起来
    
55.                         s4 = s3 + "." + s2;
    
56.                         // System.out.println(s4);
    
57.                         // 用StringBuffer将拼接后的字符串接收
    
58.                         sb.append(s4 + " ");
    
59.                         // System.out.println(str1);
    
60.                 }
    
61.                 // 切割sb并加入数组
    
62.                 String[] str1 = sb.toString().split(" ");
    
63.                 // 排序
    
64.                 Arrays.sort(str1);
    
65.                 for (String str2 : str1) {
    
66.                         // 用空字符替换IP中所有零
    
67.                         String str3 = str2.replace("0", "");
    
68.                         System.out.println(str3);
    
69.                 }
    
70.         }
    
71. 
    
72.         public void writerDemo() {
    
73.                 // 创建字符流对象
    
74.                 // FileWriter fw = null;
    
75.                 BufferedWriter bw = null;
    
76.                 try {
    
77.                         FileWriter fw = new FileWriter("d:\\IP.txt");
    
78.                         // 将需要提高效率的流对象作为参数传递给缓冲区
    
79.                         bw = new BufferedWriter(fw);
    
80.                         bw.write(str);
    
81.                         // 刷新
    
82.                         bw.flush();
    
83.                 } catch (Exception e) {
    
84.                         e.printStackTrace();
    
85.                 } finally {
    
86.                         try {
    
87.                                 bw.close();
    
88.                         } catch (IOException e) {
    
89.                                 e.printStackTrace();
    
90.                         }
    
91.                 }
    
92.         }
    
93. }
    

复制代码

牛叉:lol

这个用正则很快的

richaled 发表于 2015-5-18 08:02
这个用正则很快的

正则我还没学会，所以就用了，自己知道的一些知识来完成:)

很清晰，受教了

这是我用正则表达式写的，可以看看。

1. import java.io.BufferedWriter;
   
2. import java.io.FileWriter;
   
3. import java.io.IOException;
   
4. import java.util.TreeSet;
   
5. 
   
6. /*
   
7. * 3. 把以下IP存入一个txt文件，编写程序把这些IP按数值大小，从小到达排序并打印出来。
   
8. * 61.54.231.245
   
9. * 61.54.231.9
   
10. * 61.54.231.246
    
11. * 61.54.231.48
    
12. * 61.53.231.249
    
13. */
    
14. public class Test3 {
    
15. 
    
16.         public static void main(String[] args) throws IOException {
    
17.                 ipToprint();
    
18. 
    
19.         }
    
20.         public static void ipToprint() throws IOException{
    
21.                 BufferedWriter bufw=new BufferedWriter(new FileWriter("ip.txt"));
    
22.                 String str="61.54.231.245 61.54.231.9 61.54.231.246 61.54.231.48 61.53.231.249";
    
23.                 StringBuilder sb=new StringBuilder(str);
    
24.                 ipsort(str);
    
25.                 bufw.write(sb.toString());
    
26.                 bufw.flush();
    
27.                
    
28.         }
    
29.         //定义一个方法，对传入的IP地址进行排序
    
30.         public static void ipsort(String ipstr){
    
31.                 //每一段数字补两位零
    
32.                 ipstr=ipstr.replaceAll("(\\d+)", "00$1");
    
33.                 //每一段保留三位数字
    
34.                 ipstr=ipstr.replaceAll("0*(\\d{3})", "$1");
    
35.                 //1.将IP地址切出
    
36.                 String[]ips=ipstr.split(" +");
    
37.                 TreeSet<String>ts=new TreeSet<String>();
    
38.                 for(String ip:ips){
    
39.                         ts.add(ip);
    
40.                 }
    
41.                 for(String IP:ts){
    
42.                         System.out.println(IP.replaceAll("0*(\\d+)", "$1"));
    
43.                 }
    
44.         }
    
45. 
    
46. }

复制代码

楼主很牛啊

建议楼主学习正则，毕老师视频里面就有。
另外在分析了一下楼主的代码给楼主一些建议，你的这段代码

1. for (String str2 : str1) {
   
2.                         // 用空字符替换IP中所有零
   
3.                         String str3 = str2.replace("0", "");
   
4.                         System.out.println(str3);
   
5.                 }

复制代码

1、要想办法去掉的是无效的零而不是全部的零，不然如果是类似“010的”替换完成就成了“1”，这是有bug的；2、还有楼主的前面部分的切割如果也有一位或两位的字符，楼主也应该加一些判断，并把所使用的补零操作
嵌入进去，这样就能自由的对任意字段的一位或两位补零，以及进行下面的相关操作，希望对楼主有帮助。
3、还是去学学正则吧，比较简单，哈哈

piaoguoaaaa

KK要有光 发表于 2015-5-18 09:33
这是我用正则表达式写的，可以看看。

哎，感觉正则表达式省了不少事呀，我的太繁琐了，受教了

王建伟 发表于 2015-5-18 09:48
建议楼主学习正则，毕老师视频里面就有。
另外在分析了一下楼主的代码给楼主一些建议，你的这段代码

我的小程序正如你所说，存在很大的局限性，只能用在这道题上，你分析的很透彻呀，后面一定要学学正则！

好多牛人啊