java学习笔记(五)

最新推荐文章于 2022-02-18 11:06:45 发布

努力努力努力go

最新推荐文章于 2022-02-18 11:06:45 发布

阅读量111

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_41302368/article/details/96186211

版权

Collection

Collection是所有单例集合的父接口，因此在Collection定义了单例集合(List和Set）通用的一些方法，这些方法可用于操作所有的单例集合。

方法：

boolean add(E e) ：
把给定的对象添加的集合中，
void clear()
清空集合中的所有元素
boolean remove(E e)
把给定的对象从集合中删除，如果集合中没有这个给定的对象，就返回false，如有，返回true
boolean contains(E,e)
判断当前集合是否包含个给定的对象
*boolean IsEmpty()
判断该集合是否为空
int size()
返回集合中元素的个数
Object [] toArray()
把集合中的元素，存储到数组中

package zlb.day02.demo01;
import java.util.ArrayList;
import java.util.Collection;
public class DemoCollection {
    public static void main(String[] args) {
        //创建集合对象,多态，父类new子类
        Collection<String>  coll=new ArrayList<>();
        //往集合添加元素
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        System.out.println(coll);
        say();
        //如果移除了一个元素，则返回true
        boolean b=coll.remove("李四");
        System.out.println(b);
        System.out.println(coll);
        say();
        //没有移除元素，返回false
        boolean boolea=coll.remove("abc");
        System.out.println(boolea);
        System.out.println(coll);
        say();
        //判断集合是否包含指定的元素，若有则返回true，否则false
        boolean b1=coll.contains("张三");
        System.out.println(b1);
        say();
        //判断集合是否为空，若为空则返回true，否则false
        boolean b2=coll.isEmpty();
        System.out.println(b2);
        say();
        //把集合中的元素存储到数组
        Object[] array=coll.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        //清空集合中的所有元素
        coll.clear();
        System.out.println(coll);
    }
    public static  void say()
    {
        System.out.println("===========");
    }
}

在这里插入图片描述

Iterator: 迭代器(对集合遍历)

常用方法：

boolean hasNext()
如果仍有元素返回，则返回true
判断集合中还有你有下一个元素，有就返回true，没有就返回false
E next()
返回迭代的下一个元素，取出集合的下一个元素
Iterator迭代器是一个接口，我们无法直接使用，需要使用Iterator的实现类获取
方式:
Collection接口中有一个方法iterator，这个方法返回迭代器的实现类对象。
Iterator itertor() 返回此collection的元素上进行迭代的迭代器

package zlb.day02.demo01;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class DemoIterator {
    public static void main(String[] args) {
       //创建集合对象
        Collection<String> coll = new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        //通过集合当中的iterator()方法获取迭代器的实现类对象,并且会把指针指向结合的-1索引
        Iterator<String> it = coll.iterator();
        //while循环取出集合的所有元素
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //元素已被全部取出
        System.out.println(it.hasNext());//false

    }
}

在这里插入图片描述

增强for循环

所有单例集合都能使用增强for循环。

package zlb.day02.demo01;
import java.util.ArrayList;
import java.util.Collection;
//增强for循环，所有单例集合都能使用增强for循环
public class DemoForEach {
    public static void main(String[] args) {
        demo01();
        demo02();
    }
        //遍历数组
    public static void demo01() {
        int [] arrray={1,2,3,4,5};
        //增强for循环，其中i代表数组的每一个元素
        for (int i : arrray) {
            System.out.println(i);
        }
    }
    //遍历集合
   public static void demo02() {
       Collection<String> coll=new ArrayList<>();
       coll.add("张三");
       coll.add("李四");
       coll.add("王五");
       coll.add("赵六");
       System.out.println(coll);
       for (String s : coll) {
           System.out.println(s);
       }
    }

}

在这里插入图片描述

泛型

泛型：是一种未知的数据类型，当我们不知道使用什么类型的数据类型时，可以使用泛型，泛型也可以看作一个变量，用来接收数据。

创建对象时确定数据类型。
使用泛型的好处：
创建集合，不使用泛型：

好处：
集合不使用泛型，默认的类型为Object类型，可以存储任意类型的数据；
弊端：
不安全，会引发异常。

创建集合，使用泛型

好处
1.避免了类型转换的麻烦，存储什么类型，取出的就是什么类型。
2.把运行期异常(代码运行之后抛出异常)，提升到了编译期异常(编写代码时会报错)

package zlb.day02.demo02;
import java.util.ArrayList;
import java.util.Iterator;
public class DemoGeneric {
    public static void main(String[] args) {
        demo01();
    }
    private static void demo01() {
        ArrayList list=new ArrayList ();
        list.add("胡歌");
        list.add(123);
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Object next = it.next();
            System.out.println(next);
            //使用String特有的方法length,需要向下转型
            //把Object类强转为String类
            //会抛出类型转换异常，不能把Integer类型转换为String类型
            String s = (String) next;
            int length = s.length();
            System.out.println(length);
        }
    }
   
}

在这里插入图片描述
package zlb.day02.demo02;
import java.util.ArrayList;
import java.util.Iterator;
public class DemoGeneric {
public static void main(String[] args) {
demo02();
}

private static void demo02(){
    ArrayList<String> list=new ArrayList<>();
    list.add("abc");
    //list.add(24);//不能向list集合中存储int类型数据,编译代码时会报错
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        String next = it.next();
        System.out.println(next);
        int length = next.length();
        System.out.println(length);
    }
}

}
在这里插入图片描述

可以使用泛型定义类

package zlb.day02.demo02;
//定义一个含有泛型的类
public class GenericClass<E> {
    private  E name;
    public E getName() {
        return name;
    }
    public void setName(E name) {
        this.name = name;
    }
    public static void main(String[] args) {
        //创建GenericClass，泛型使用String
        GenericClass<String> obj = new GenericClass<>();
        obj.setName("胡歌");
        System.out.println(obj.getName());
        
        //创建GenericClass，泛型使用Integer
        GenericClass<Integer> name = new GenericClass<>();
        name.setName(1);
        System.out.println(name.getName());

    }
}

在这里插入图片描述

可以使用泛型定义方法

package zlb.day02.demo02;
//定义含有泛型的方法
public class GenericMethod {
//定义一个含有泛型的方法
public void method01 (E e){
System.out.println(e);
}
//定义一个含有泛型的静态方法
public static void method02(M m){
System.out.println(m);
}
public static void main(String[] args) {
GenericMethod gm=new GenericMethod();
gm.method01(“abc”);
gm.method01(1);
gm.method01(true);
gm.method01(3.3);
method02(5);
}

}
在这里插入图片描述
可以使用泛型定义接口

//接口
package zlb.day02.demo02;
//使用泛型定义接口
public interface GenericInterface<M> {
    public  abstract void add(M m);
}
//接口实现类
package zlb.day02.demo02;
public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void add(String s) {
        System.out.println(s);
    }
    public static void main(String[] args) {
        GenericInterfaceImpl impl1=new GenericInterfaceImpl();
        impl1.add("abc");

    }
}

//接口
package zlb.day02.demo02;
//使用泛型定义接口
public interface GenericInterface<M> {
    public  abstract void add(M m);
}

package zlb.day02.demo02;
//接口使用什么泛型，实现类使用什么泛型
//创建对象时确定泛型的类型
public class GenericInterfaceImpl2<M> implements GenericInterface<M> {
    @Override
    public void add(M m) {
        System.out.println(m);
    }
    public static void main(String[] args) {
        GenericInterfaceImpl2<String> gc1 = new GenericInterfaceImpl2<>();
        gc1.add("abc");
        GenericInterfaceImpl2<Integer> gc2 = new GenericInterfaceImpl2<>();
        gc2.add(2);
    }
}

在这里插入图片描述

泛型通配符

?:代表任意的数据类型

使用方式：

不能创建对象使用
只能作为方法的参数使用

public class Demo02Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list01=new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02=new ArrayList<>();
        list02.add("abc");
        list02.add("张三");
        print(list01);
        System.out.println("=======");
        print(list02);
        //定义一个方法遍历所有类型的ArrayList集合,
        // 这时我们不知道ArrayList集合使用什么类型，可以使用泛型通配符？来接收数据类型
    }
    public static  void print(ArrayList<?> list)
    {
        Iterator<?> it = list.iterator();
        while(it.hasNext())
        {
            Object next = it.next();
            System.out.println(next);
        }
    }
}

在这里插入图片描述

努力努力努力go

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java学习笔记(五)

CollectionCollection是所有单例集合的父接口，因此在Collection定义了单例集合(List和Set）通用的一些方法，这些方法可用于操作所有的单例集合。方法：boolean add(E e) ：把给定的对象添加的集合中，void clear()清空集合中的所有元素boolean remove(E e)把给定的对象从集合中删除，如果集合中没有这个给定的对象，就...
复制链接

扫一扫