Day16_List_Son_Generic_JDK5News

最新推荐文章于 2024-08-11 22:39:50 发布

youmingke

最新推荐文章于 2024-08-11 22:39:50 发布

阅读量140

点赞数

分类专栏： Java

Java 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Da16总结：

1:List的子类(掌握)
   (1)List的子类特点
       ArrayList:
           底层数据结构是数组，查询快，增删慢
           线程不安全，效率高
       Vector:
           底层数据结构是数组，查询快，增删慢
           线程安全，效率低
       LinkedList:
           底层数据结构是链表，查询慢，增删快
           线程不安全，效率高

(2)ArrayList

       A:没有特有功能需要学习
       B:案例
           a:ArrayList存储字符串并遍历
           b:ArrayList存储自定义对象并遍历

ArrayList<String> list =new ArrayList<String>();

list.add("我");

  for(int i=0;i<list.size();i++)
       {
           String s=list.get(i);
           System.out.println(s);
       }

Iterator<String> listIt=list.iterator();

while(listIt.hasNext())
       {
           String s=listIt.next();
           System.out.println(s);
       }
       System.out.println("------------");


       while(listIt.hasPrevious())
       {
           String s=listIt.previous();
           System.out.println(s);
       }

/*
* ArrayList 去除集合中字符串的重复值(字符串的内容相同)
* 方法一：
* 分析:
*     A:创建集合对象
*     B:添加多个字符串元素(包含内容相同的元素)
*     C:创建新集合
*     D:遍历旧集合，获取得到每一个元素
*     E:将获取到的元素与新集合比较，看新集合中有没有
*         有:什么也不做
*         没有:添加到新集合
*     F:遍历新集合
*
* 方法二：不创建新的集合，就在本来的集合上做，根据选择排序的思想做
*
*/

ArrayList array=new ArrayList();

       array.add("Hello");
       array.add("World");
       array.add("Java");
       array.add("Hello");
       array.add("Hello");
       array.add("Hello");
       array.add("Hello");
       array.add("World");
       array.add("Java");
       array.add("World");
       array.add("Java");



       //方法一：
       /*
       ArrayList newArray=new ArrayList();
       Iterator it =array.iterator();
       while(it.hasNext())
       {
           String s=(String)it.next();
           if(!newArray.contains(s))
           {
               newArray.add(s);
           }
       }
       for(int i=0;i<newArray.size();i++)
       {
           String s=(String)newArray.get(i);
           System.out.println(s);
       }

       */

       //方法二：拿当前索引的元素依次与后面的进行比较，有的话就把后面的删除

       for(int i=0;i<array.size();i++)
           for(int j=i+1;j<array.size();j++)
           {
               if(array.get(i).equals(array.get(j)))
               {
                       array.remove(j);
                       j--; //重要的地方：每次连续相同的两个元素在一起时，
                           //前一个被删掉了，然后后一个向上补到这一个索引，而这一个索引之前被if比较过了，索引j++了
                           //因此，移除后，j要减减
               }
           }
       Iterator it =array.iterator();
       while(it.hasNext())
       {
           String s=(String)it.next();
           System.out.println(s);
       }

/*
* 需求:去除集合中自定义对象的重复值（对象的成员变量值都相同）
*
* 我们按照和字符串一样的操作，发现出问题了
* 为什么呢？
* 我们必须思考那一段代码出问题了？
* 通过简单的分析，我们知道了问题出现在了判断上（contains()方法）
* 通过查看源码，发现contains()方法的底层依赖的是equals()方法。
* 而我们的学生类中并没有equals()方法，这个时候，默认使用的是它的父类Object的equals()方法
* 而Object的equals()方法默认比较的是地址值，所以，并没有把重复的对象去掉，因为new出来的对象，地址值都不相同
*
* 按照需要，我们需要重写自定义类中的equals()方法，自动生成即可。
*/

(3)Vector

       A:有特有功能
           a:添加
               public void addElement(E obj)       --   add()
           b:获取
               public E elementAt(int index)       --   get()
               public Enumeration<E> elements()   -- iterator()
       B:案例
           a:Vector存储字符串并遍历
           b:Vector存储自定义对象并遍历

Vector ve = new Vector();

       ve.addElement("wo");
       ve.addElement("yao");
       ve.addElement("zhao");
       ve.addElement("zhang");
       ve.addElement("yao");
       ve.addElement("zuo");
       ve.addElement("wo");
       ve.addElement("girl");

       for (int i = 0; i < ve.size(); i++)
       {
           String s = (String) ve.elementAt(i);
           System.out.println(s);
       }

       System.out.println("----------");

       Enumeration en = ve.elements();
       while (en.hasMoreElements())
       {
           String s = (String) en.nextElement();
           System.out.println(s);

}

(4)LinkedList

       A:有特有功能
           a:添加
               addFirst()
               addLast()
           b:删除
               removeFirst()
               removeLast()
           c:获取
               getFirst()
               getLast()
       B:案例
           a:LinkedList存储字符串并遍历
           b:LinkedList存储自定义对象并遍历

LinkedList llist = new LinkedList();

       llist.add("wo");
       llist.add("yao");
       llist.add("you");
       llist.add("be");
       llist.add("my");
       llist.add("girl");

llist.addFirst("yi ding yao,");
llist.addLast("qiang lie de yu wang");

System.out.println(llist);
System.out.println("----------");

       Iterator it = llist.iterator();
       while (it.hasNext())
       {
           String s = (String) it.next();
           System.out.println(s);
       }

System.out.println("----------");

System.out.println("removeFist:" + llist.removeLast());
System.out.println("removeLast:" + llist.removeFirst());

(5)案例：

       A:去除集合中的多个字符串的重复元素
           如果字符串的内容相同，即为重复元素
       B:去除集合中的多个自定义对象的重复元素
           如果自定义对象的成员变量值都相同，即为重复元素
       C:用LinkedList模拟一个栈数据结构的集合类，并测试。
           你要定义一个集合类，只不过内部可以使用LinkedList来实现。

2:泛型(掌握)

   (1)泛型概述
       是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
   (2)格式：
       <数据类型>
       注意：该数据类型只能是引用类型。
   (3)好处：
       A:把运行时期的问题提前到了编译期间
       B:避免了强制类型转换
       C:优化了程序设计，解决了黄色警告线问题，让程序更安全
   (4)泛型的前世今生
       A:泛型的由来
           Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题
       B:泛型类
       C:泛型方法
       D:泛型接口
       E:泛型高级通配符
           ?
           ? extends E
           ? super E
   (5)我们在哪里使用呢?
       一般是在集合中使用。

3:增强for循环(掌握)

   (1)是for循环的一种
   (2)格式：
       for(元素的数据类型变量名 : 数组或者Collection集合的对象) {
           使用该变量即可，该变量其实就是数组或者集合中的元素。
       }
   (3)好处：
       简化了数组和集合的遍历
   (4)弊端
       增强for循环的目标不能为null。建议在使用前，先判断是否为null。

4:静态导入(了解)
   (1)可以导入到方法级别的导入
   (2)格式：
       import static 包名....类名.方法名;
   (3)注意事项：
       A:方法必须是静态的
       B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。
           所以一般我们并不使用静态导入，但是一定要能够看懂。

5:可变参数(掌握)

   (1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
   (2)格式：
       修饰符返回值类型方法名(数据类型... 变量) {}

       注意：
           A:该变量其实是一个数组名
           B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后
   (3)Arrays工具类的一个方法
       asList()把数组转成集合。
       注意：这个集合的长度不能改变。