package myjava.day16_01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* @author n snow 一个字符串集合ArrayList中含有如下元素： hello, world, java, hello, .net,
*         java, php, ios, java, android，world。 要求编写程序，获得一个没有重复元素的新集合。 思想：
*         A:遍历集合， B:取第一个元素和后面的元素对比 C:相同则删除后面相同的元素 D:并获得一个新的集合，
*         E:然后取第二个元素，重复上面步骤
* */
public class CollectionDemo {
        public static void main(String[] args) {
                List list = new ArrayList();
                list.add("hello");
                list.add("world");
                list.add("java");
                list.add("hello");
                list.add(".net");
                list.add("java");
                list.add("php");
                list.add("ios");
                list.add("java");
                list.add("android");
                list.add("world");
                List list2 = new ArrayList();
                Iterator it = list.iterator();
                for (int j = 0; j < list.size()-1; j++) {
                               
                        for (int i = 1; i < list.size()-1; i++) {
                                while (it.hasNext() && list.get(j).equals(list.get(i))) {
                                        list.remove(i);       
                                       
                                }               
                        }       
                }
                System.out.println(list);
        }
}
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 1, Size: 1
        at java.util.ArrayList.rangeCheck(ArrayList.java:635)
        at java.util.ArrayList.get(ArrayList.java:411)
        at myjava.day16_01.CollectionDemo.main(CollectionDemo.java:32)
索引越界异常
虽然我这个程序的设计有问题 但是我感觉语句上能运行啊  但是报错了
视频和讲师都是用新建集合接收contain语句判断来做的  我这是想直接操作该集合本身

把迭代器去掉 和nexthas去掉报同样的错误

1. package day16;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. 
   
7. /**
   
8. * 思想： 1：遍历取出原集合中的每个元素； 2：判断新集合中是否有相同元素，如果不包含，则添加； 3：打印新集合
   
9. * */
   
10. public class CollectionDemo {
    
11.         public static void main(String[] args) {
    
12.                 List<String> list = new ArrayList<String>();
    
13.                 list.add("hello");
    
14.                 list.add("world");
    
15.                 list.add("java");
    
16.                 list.add("hello");
    
17.                 list.add(".net");
    
18.                 list.add("java");
    
19.                 list.add("php");
    
20.                 list.add("ios");
    
21.                 list.add("java");
    
22.                 list.add("android");
    
23.                 list.add("world");
    
24. 
    
25.                 List<String> list2 = new ArrayList<String>();
    
26.                 for (Iterator<String> it = list.iterator(); it.hasNext();) {
    
27.                         String str = it.next();
    
28.                         if (!list2.contains(str)) {
    
29.                                 list2.add(str);
    
30.                         }
    
31.                 }
    
32. 
    
33.                 System.out.println(list2);// 打印新集合元素
    
34.         }
    
35. }

复制代码

这样做简单。。。。

michael_wlq 发表于 2015-10-1 11:52
这样做简单。。。。

这样做 我会啊 ~但是 我就想就在这个集合身上动刀 ，不创建新的新的集合就达成同样的效果啊

1.    List list = new ArrayList();
   
2.           list.add("hello");
   
3.           list.add("world");
   
4.           list.add("java");
   
5.           list.add("hello");
   
6.           list.add(".net");
   
7.           list.add("java");
   
8.           list.add("php");
   
9.           list.add("ios");
   
10.           list.add("java");
    
11.           list.add("android");
    
12.           list.add("world");
    
13.           //List list2 = new ArrayList();  
    
14.           Iterator it = list.iterator();
    
15.           for (int j = 0; j < list.size()-1; j++) {
    
16.                   for(int i=j+1;i<list.size();i++){
    
17.                           /*while (it.hasNext() && list.get(j).equals(list.get(i))) {
    
18.                       list.remove(i);   */  
    
19.                           
    
20.                           if(list.get(j).equals(list.get(i)))
    
21.                           {
    
22.                                   list.remove(i);
    
23.                           }
    
24.                   }
    
25.                           
    
26.                
    
27.           }
    
28.          
    
29.           System.out.println(list);

复制代码

楼夜雪 发表于 2015-10-1 12:03
这样做 我会啊 ~但是 我就想就在这个集合身上动刀 ，不创建新的新的集合就达成同样的效果啊 ...

不需要创建新的集合

这种问题就要自己测试    帮你每次结果截图了


你想法是用冒泡法2个2个相互比较  相等就剔除掉一个，是吧，你定义list2也不用。。。。想法是美好的事实的情况是。

你没while执行一次就会剔除掉数组[1]坐标的值，剔除到最后只剩下一个hello这时hello的坐标是数组[0],你却remove[i] 也就是remove[1]出现数组越界异常

以后while慎用  ，集合内部比较你这用到了冒泡法  思想不错  比那些只知道直接调用方法的好多了，     list2别new 了帮你while换成if看看结果吧骚年

boboyuwu 发表于 2015-10-1 15:01
以后while慎用  ，集合内部比较你这用到了冒泡法  思想不错  比那些只知道直接调用方法的好多了，     list ...

谢谢大神指导我现在又有一个问题你看下下面的代码

package day08;

public class Grade1Student extends Student{
        private String name;
        private int age;
        private String sex;
        private String School;
        private static int grade;
        public Grade1Student() {
                super();
                // TODO Auto-generated constructor stub
        }
        public Grade1Student(String name, int age, String sex, String name2,
                        int age2, String sex2, String school, int grade) {
                super(name, age, sex, name2, age2, sex2, school, grade);
                // TODO Auto-generated constructor stub
        }
        public Grade1Student(String name, int age, String sex) {
                super(name, age, sex);
                // TODO Auto-generated constructor stub
        }
        public Grade1Student(String name, int age) {
                super(name, age);
                // TODO Auto-generated constructor stub
        }
        public Grade1Student(String name, int age, String sex, String school) {
                super();
                this.name = name;
                this.age = age;
                this.sex = sex;
                School = school;//静态变量没有this关键字
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }
        public String getSex() {
                return sex;
        }
        public void setSex(String sex) {
                this.sex = sex;
        }
        public String getSchool() {
                return School;
        }
        public void setSchool(String school) {
                School = school;
        }
        public static int getGrade() {
                return grade;
        }
        public static void setGrade(int grade) {
                Grade1Student.grade = grade;
        }
}
//我想创建一个四年级的学生类，于是把年级定义成静态
但是eclipse自动给出的Gradeget set方法也是静态的，但是报错了 为什么？
方法去掉static之后就OK了
这是在同一个类里面  而且都是静态的 为什么会报错啊 静态调用静态 思想没错吧

1. import java.util.ArrayList;
   
2. import java.util.List;
   
3. import java.util.ListIterator;
   
4. 
   
5. public class ListDemo {
   
6.         public static void main(String[] args) {
   
7.                 List<String> list = new ArrayList<String>();
   
8.                 list.add("hello");
   
9.                 list.add("world");
   
10.                 list.add("java");
    
11.                 list.add("hello");
    
12.                 list.add(".net");
    
13.                 list.add("java");
    
14.                 list.add("php");
    
15.                 list.add("ios");
    
16.                 list.add("java");
    
17.                 list.add("android");
    
18.                 list.add("world");
    
19.                 System.out.println(list);
    
20.                 System.out.println("---------");
    
21.                 ListIterator<String> lt = list.listIterator();
    
22.                 while (lt.hasNext()) {
    
23.                         String s = lt.next();
    
24.                         if (list.indexOf(s) != list.lastIndexOf(s)) {
    
25.                                 lt.remove();
    
26.                         }
    
27.                 }
    
28.                 System.out.println(list);
    
29.         }
    
30. }
    

复制代码

用Iterator对象调用remove()就不会报错了。