问题就是   1、我模拟的Collections.fill() 原理是否正确，
               2、后续扩展的【规律性替换】是否有意义。

今天在看毕老师就Collections 工具类的讲解
知道了 Collections.fill() 实现了替换集合中的所有元素的功能。

然后老师留了一个小练习，需求是替换集合中的部分元素。

然后我就开始先模拟Collections.fill() 方法的原理， 功能倒是实现了，总感觉似乎不对。
还请大家看看是不是正确的。
同时根据自己写的这个原理扩展出了，替换部分元素的功能，完成了小练习的功能

再最后又突发奇想的，能不能在替换的时候按照某种规律进行替换，

于是又有了 2个小功能，分别对int类型集合，string 类型集合进行了规律替换。
具体代码如下：

1. import java.util.*;
   
2. class CollectionsDemo3
   
3. {
   
4.         public static void main(String[] args)
   
5.         {               
   
6.                 filldemo();
   
7.                 kuoFill();//扩展部分
   
8.         }
   
9.         /**
   
10.                 fill方法可以将list集合中的所有元素替换成指定元素
    
11.                 练习：将list集合中的部分元素替换成指定元素。
    
12.         */
    
13.         //Collections.fill(list,"pppppp");
    
14.         public static void filldemo(){
    
15.                 sop("替换功能演示、原理、小练习");
    
16.                 List<String> list = new ArrayList<String>();
    
17.                 //新增元素。
    
18.                 list.add("a");
    
19.                 list.add("ag");
    
20.                 list.add("dfd");
    
21.                 list.add("ggggs");
    
22.                 list.add("z");
    
23.                 list.add("dd");
    
24.                 sop("原集合     ："+list);
    
25.                 Collections.fill(list,"YY");//Collections下fill工具进行替换
    
26.                 sop("fill替换   ："+list);
    
27.                 list=moniFill(list,"qq");//自定义模拟fill原理 替换
    
28.                 sop("模拟替换   ："+list);
    
29.                 list=onlyFill(list,2,4,"mm");// 练习题，基于fill原理进行扩展  替换
    
30.                 sop("部分替换   ："+list);
    
31.                 list=stringFill(list,"i");//  突发奇想的，进行了规律性替换
    
32.                 sop("功能延伸   ："+list);               
    
33.         }
    
34.         //模拟Fill 替换
    
35.         public static List<String> moniFill(List<String> list,String str){
    
36.                 //创建一个新集合
    
37.                 List<String> nlist =new ArrayList<String>();
    
38.                 //使用迭代器获取原集合的长度（元素个数），通过遍历新增（相同个数/长度的 元素）被替换值。
    
39.                 for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){        
    
40.                         if(!it.next().equals(str))//每遍历一次，插入一个对应的替换值。
    
41.                                 nlist.add(str);
    
42.                 }
    
43.                 return nlist;
    
44.         }
    
45.         //基于模拟替换 延伸出部分替换
    
46.         public static List<String> onlyFill(List<String> list,int start,int end,String str){               
    
47.                 List<String> nlist =new ArrayList<String>();
    
48.                 int num=0;
    
49.                 for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){                                
    
50.                         if(num<start||num>end-1){//end-1 是为了符合Java包含头，不包含尾的特性。
    
51.                                 nlist.add(it.next());
    
52.                         }else if(!it.next().equals(str)){//把每一个it.next() 都更改为str
    
53.                                 nlist.add(str);
    
54.                         }
    
55.                         num++;
    
56.                 }
    
57.                 return nlist;
    
58.         }
    
59.         //延伸  一个小小的延伸功能。让一个int类型的集合被替换为某种规律的集合。
    
60.         public static List<Integer> intFill(List<Integer> list,int str){
    
61.                 List<Integer> lint =new ArrayList<Integer>();
    
62.                 for(Iterator<Integer> it = list.iterator() ; it.hasNext() ; ){        
    
63.                         if(!it.next().equals(str))
    
64.                                 lint.add(str);
    
65.                                 str+=9;
    
66.                 }
    
67.                 return lint;
    
68.         }
    
69.         //对int类型的集合，进行规律性的替换
    
70.         public static void kuoFill(){
    
71.                 sop("\n扩展部分，让一个int集合被替换为某种规律的集合");
    
72.                 List<Integer> lint = new ArrayList<Integer>();
    
73.                 lint.add(2);
    
74.                 lint.add(99);
    
75.                 lint.add(76);
    
76.                 lint.add(76);
    
77.                 lint.add(76);
    
78.                 sop("原集合     ："+lint);
    
79.                 lint=intFill(lint,5);// 按某种规律进行替换。
    
80.                 sop("成规律替换 ："+lint);
    
81.         }
    
82.         //延伸  让一个String类型的集合被替换为某种规律的集合。
    
83.         public static List<String> stringFill(List<String> list,String str){
    
84.                 List<String> nlist =new ArrayList<String>();
    
85.                 for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){        
    
86.                         if(!it.next().equals(str))
    
87.                                 nlist.add(str);
    
88.                                 str+=str+"O";
    
89.                 }
    
90.                 return nlist;
    
91.         }
    
92.         //打印语句
    
93.         public static void sop(Object obj){
    
94.                 System.out.println(obj);
    
95.         }
    
96. }
    

复制代码

:(

没有高手出来指点指点吗。

难道是问题太白吃了吗。

你测试能替换吗

gentleman 发表于 2014-5-21 20:45
你测试能替换吗

测试OK   
完成功能没问题。

只是感觉好像可能估计也许大概好像可能估计不是最正确的写法。

问题在于：你下面的这两个功能意义不大。你看看原集合和你替换之后的集合关系大吗?为什么不直接新建个集合，直接将有规律的对象，添加到集合中？
//对int类型的集合，进行规律性的替换

70.        public static void kuoFill(){

71.                sop("\n扩展部分，让一个int集合被替换为某种规律的集合");

72.                List<Integer> lint = new ArrayList<Integer>();

73.                lint.add(2);

74.                lint.add(99);

75.                lint.add(76);

76.                lint.add(76);

77.                lint.add(76);

78.                sop("原集合     ："+lint);

79.                lint=intFill(lint,5);// 按某种规律进行替换。

80.                sop("成规律替换 ："+lint);

81.        }

82.        //延伸  让一个String类型的集合被替换为某种规律的集合。

83.        public static List<String> stringFill(List<String> list,String str){

84.                List<String> nlist =new ArrayList<String>();

85.                for(Iterator<String> it = list.iterator() ; it.hasNext() ; ){        

86.                        if(!it.next().equals(str))

87.                                nlist.add(str);

88.                                str+=str+"O";

89.                }

90.                return nlist;

91.        }

zhrnghgwsws 发表于 2014-5-21 23:52
问题在于：你下面的这两个功能意义不大。你看看原集合和你替换之后的集合关系大吗?为什么不直接新建个集合 ...

说的挺有道理，
多谢多谢。

使用指定元素替换指定列表中的所有元素。