HTTP header整理 HTTP 请求头(Accept-Encoding,User-agent,Referer)

Java常用类:包装类

  返回  

JAVA day10:集合笔记2(迭代器、泛型、list\Set、Collections工具类)

2021/8/20 22:45:54 浏览:

一、 Iterator迭代器

1.1 Iterator接口

在程序开发中,经常需要遍历集合的所有元素,针对这种需求,JDK专门提供了一个接口

java.util.Iterator,Iterator

接口也是集合中一员,但它与Collection,Map接口功能不一样,前者是为了存储元 素,而后者专门用于迭代访问(遍历)Collection中元素,也称为迭代器。

想要遍历实现了Collection接口集合元素,要用通用方法

public Iterator iterator();获取集合中对就迭代器,用来遍历其中元素。

1.2 迭代的概念

迭代:在集中取元素时,先要判断集合有没有元素,如果有,就把元素取出来,再接着进行判断, 如果有接着取出来,一直到把集合中所有的元素全部取出来,这种取出的方式叫做迭代。

Iterator接口常用方法如下:

public E next();返回迭代中下一个元素

public boolean hasNext();如果仍有元素,返回True/false

实例:

//将四个城市保存到set集合容器中
		//第1步:创建并实例化一个HashSet集合容器//HashSet集合容器的特点:
		//(1)在HashSet中保存的元素是无序的
		//(2)在HashSet中保存的元素是唯一的(也就是说:HashSet中不会存在相同的元素)
		//(3) HashSet底层原理基于Hash算法,元素没有索引,所以遍历HashSet需要使用[迭代器]Iterator
		HashSet<String> cities=new HashSet<String>();
		//第2步:通过add方法向集合容器中添加元素
		cities.add("北京");
		cities.add("上海");
		cities.add("杭州");
		cities.add("深圳");
		//***第3步:通过增强型for循环遍历HashSet集合容器获取集合容器中保存的所有元素
		for(String s : cities){
			System.out.println(s);
		}
		//第3步:通过迭代器Iterator遍历HashSet集合容器获取集合容器中保存的所有元素
		Iterator<String> itr = cities.iterator();//获取HashSet集合对象中的迭代器
		while(itr.hasNext()){//hasNext()判断是否还存在元素
			System.out.println(itr.next());//next()获取元素
			//删除
			if("上海".equals(itr.next())){
				itr.remove();
			}
		}
		cities.clear();//清除HashSet集合中所有的元素
	}

Iterator<String> itr = cities.iterator();//获取HashSet集合对象中的迭代器
while(itr.hasNext()){//hasNext()判断是否还存在元素
        System.out.println(itr.next());//next()获取元素
        //删除
        if("上海".equals(itr.next())){
                itr.remove();
        }
}

 1.3 迭代器实现的原理

当遍历集合时,首先通过调用集合的iterator方法获得迭代器对象,然后使用hasNext()方法判断集合中是 否还存在下一个元素,如果存在,则调用next()方法取出,返回false代表已达到集合的末尾,停止遍历 元素。

迭代器对象iterator,遍历集合时,内部采用指针方式来跟踪集合元素,在调用next方法之前,指钱默认位 置第一个元素之前,不指向任何元素,调用next方法后,指针向后移动一位,指向第一个元素并返回元 素值,依次类推,直到指针达到末尾,终止对元素的遍历

二、 泛型

我们在集合中会大量使用到泛型。

Collection a=new ArrayList<>();

2.1 泛型的概念

泛型是一种未知的数据类型,当我们不知道使用什么数据类型时,可以使用泛型。

泛型可以看做一个变量,用来接收所有的数据类型

E e:Element元素

Tt: Type类型。

//ArrayList集合在定义时,不知道集合都有什么类型,所以类型使用泛型
//集合与数组不一样,数组只有放相同类型 int[] String[] Object[]
//集合可以放不同类型的元素 e1->String e2->Integer ...
//集合采用泛型 E -未知类型
//定义时
class ArrayList<E>{
    public boolean add(E e){};
    public E get(int index){};
}
//使用时,会把String赋值给E
class ArrayList<String>{
    public boolean add(String e){};
    public String get(int index){};
}
//使用时,会把Student赋值给E
class ArrayList<Student>{
    public boolean add(Student e){};
    public Student get(int index){};
}

2.2.定义和使用含有泛型的类

定义格式

修饰符 class 类名{ }

 例如:

class ArrayList<E>{
    public boolean add(E e){};
    public E get(int index){};
}

使用时确定泛型的类型

ArrayList<String> list=new ArrayList<String>();
//使用时,会把String赋值给E
class ArrayList<String>{
    public boolean add(String e){};
    public String get(int index){};
}

自定义泛型

// 泛型定义
public class MyGenericClass<MVP>{
//没有MVP类型,这里代表 是一种未知数据类型,未来传哈类型就赋值什么类型
    private MVP mvp;
    public MVP getMvp() {
        return mvp;
    }
    public void setMvp(MVP mvp) {
        this.mvp = mvp;
    }
}


public class GenericClassDemo {
    public static void main(String[] args) {
        //创建一个泛型为String的类
        MyGenericClass<String> my=
        new MyGenericClass<String>();
        //调用set
        my.setMvp("大胡子");
        String mvp=my.getMvp();
        System.out.println(mvp);
        //创建一个泛型为Integer类
        MyGenericClass<Integer> my1=
            new MyGenericClass<Integer>();
        //调用set
        my1.setMvp(10);
        Integer mvp1=my1.getMvp();
        System.out.println(mvp1);
        //创建一个泛型为Double类
        MyGenericClass<Double> my2=
            new MyGenericClass<Double>();
        //调用set
        my2.setMvp(11.11);
        Double mvp2=my2.getMvp();
        System.out.println(mvp2);
    }
}

2.3 定义和使用含有泛型的方法

定义格式:

修饰符 返回值类型 方法名(参数){ }

public class MyGenericMethod {
    public <MVP> void show(MVP mvp){
        System.out.println(mvp.getClass());
    }
    public <MVP> MVP show2(MVP mvp){
        return mvp;
    }
}

使用格式:调用方法时,确定泛型类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        MyGenericMethod mm=new MyGenericMethod();
        //
        mm.show("aaa");
        mm.show(123);
        mm.show(123.45);
    }
}

 2.4.定义和使用含有泛型接口

修饰符 interface接口名{}

 定义:

public interface MyGenericInterface<E>{
    void add(E e);
    public E getE();
}

使用时

public class MyImp1 implements MyGenericInterface<String>{
    void add(String e){}
    public String getE(){}
}

2.5. 泛型的通配符

通配符基本使用

通配符 :不知道使用什么类型来接收时,可以使用 ? ,?代表未知通配符

此时只能接受数据,不能向里面存储数据

实例:

public static void getElement(Collection<?> coll)

通配符高级使用--受限泛型

Java中泛型可指定上限和下限

泛型上限:

格式 类型名称<?extends类>  对象名称

意义:只能接收该类型及其子类

泛型下限

格式:类型名称<?super类> 对象名称

意义:只能接收该类型及其父类型

//泛型的上限 必须是Number类型或者是Number类型的子类型
public static void getElement1(Collection<? extends Number) coll{}
//泛型的下限 必须是Number类型或者是Nubmer类型的父类
public static void getElement3(Collection<? super Number) coll{}

三、List集合

3.1 List 接口

List接口是Collection接口的子接口。

Set接口是Collection接口的子接口

List接口是单例集合一个重要的分支,

List集合允许出现重复的元素。所有元素是以一种线性表方式进行存储,

在程序中可以通过索引访问集合中指定元素

元素有序,即元素的存入的顺序和取出顺序是一样的。

看API,总结一下 List接口的特点:

·它是一个元素存取有序的集合,

·它是一个带索引的集合 集合中可以有重复的元素,

·通过元素中equals方法,来比较是否重复元素。

 List 接口的常用方法

List是Collection集合子接口,不但继承了Collection接口的全部方法,而且还增加了特有方法

pubic void add(int index E element),將指定元素,添加到该集合指定位置 -》增

public E get(int get),通过索引返回到指元素 -》查

pubic E remove(int index),移除列表中指定位置的元素,返回是删除后元素 -》删

public E set(int index,E element):用指定的元素来替换先前的元素 -》改

实例:

public class ListDemo {
    public static void main(String[] args) {
    //创建List集合
    List<String> list=new ArrayList<>();
    // 添加指定元素
    list.add(0,"小美");
    list.add(1,"小张");
    list.add(2,"小王");
    System.out.println(list);
    //删除
    System.out.println("删除索引2的位置");
    System.out.println(list.remove(2));
    System.out.println(list);
    //修改
    list.set(0,"三毛");
    System.out.println(list);
    //查询所有
    for (String s : list) {
        System.out.println(s);
    }
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i)); //一个一个查
    }
    java.util.Iterator it=list.iterator();
    while (it.hasNext()){
        String str=(String)it.next();
        System.out.println(str);
    }
  }
}

3.2 List 的子类

 ArrayList集合

java.util.ArrayList集合数据存储的结构数组,元素增删改慢,查询快,由于日常开发中使用最多功能为 查询,遍历数据,所以ArayyList是最常用的集合。

特点

动态数组 变长 (数组 定长)

List默认初始化长度10 如果初始化长度使用完之后,自动增长新长度,默认新增长度是多少 5 -》 7-》11 -》

ArrayList 滥用,开发中尽量避免使用ArrayList完成所有任务。

public class ListDemo02 {
    public static void main(String[] args) {
        //1.创建List集合对象
        List<String> list = new ArrayList<>();
        //2.存入数据
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("二丫");
        list.add("钱六");
        list.add("孙七");
        //遍历集合
        for(int i=0;i<list.size();i++){
        //获取每一个元素
            String name=list.get(i);
        if("二丫".equals(name)){
            //将其改成
            list.set(i,"王小丫");
            }
        }
        System.out.println(list);
    }
}

 LinkedList集合

java.util.LinkedList 集合数据结构是链表结构,方便元素添加,删除的集合

LinkedList是一个双向链表,那么双向链表是什么样子

 

 public void addFirst(E e):将指定元素插入链表表开头

public void addLast(E e):将指定元素添加到此链表的末尾

public E getFirst();返回此链表的第一个元素

public E getLast();返回此链表最后一个元素

public E removeFirst();删除此链表的第一个元素

public E removeLast();删除此链表的最后一个元素

public E pop():将链表中堆栈弹出一个元素 (取)

public void push():将元素推入到此链表的堆栈

public boolean isEmpty();如果链表不包含此元素,则返回的是true

LinkedList 不光能当成链表使用,还能作为堆栈去使用。 

import java.util.LinkedList;
// 特有方法
public class LinkedListTest02 {
    public static void main(String[] args) {
        LinkedList<String> linked=
        new LinkedList<>();
        linked.add("周杰伦");
        linked.add("周润发");
        linked.add("周星驰");
        linked.add("周华键");
        // 添加到头部
        linked.addFirst("周传雄");
        // 添加到尾部
        linked.addLast("周瑜民");
        System.out.println(linked);
        System.out.println(linked.getFirst());
        System.out.println(linked.getLast());
        // 删除
        System.out.println(linked.removeFirst());
        System.out.println(linked.removeLast());
        System.out.println("=============");
        // 使用pop弹出第一个元素
        String p=linked.pop();
        System.out.println(p);
        System.out.println("===========");
        // 使用push方法向开头增加元素 push 只能头部增加,不能尾部增加
        linked.push("周立波");
        System.out.println(linked);
        // clear
        linked.clear();
        System.out.println(linked);
    }
}

 四、Set接口

java.uti.Set接口和java.util.List接口一样,继承自Collection接口,也可以继承Collection接口通用方法。和 List不一样并没有进行功能扩充,只是比Collection接口更加严格。与List接口不一样的是:Set接口元素 无序,并且都会以某种规则保证存入元素不出现重复。

Set接口有多个子类,java.uti.HastSet,和Java.util.LinkedHashSet集合

Set集合取出元素可以采用:迭代器,增加for

 4.1 HashSet

java.util.HashSet是接口Set的一个实现类,它存储的元素是不可重复的,并且元素是无序(即存入的顺 序和取出的顺序不一样)java.util.HashSet底层实现实际是一个java.util.HashMap.先了解一下。

*HashSet是根据对象的Hash值来确定元素在集合中的存储位置, 因此* 良好的存取和查找性能。可以保 保证元素的唯一性。

public static void main(String[] args) {
    // 哈希值是一组不规则数字
    String h="abc";
    System.out.println(h.hashCode());
    System.out.println("===========");
    // 特征1:相同输入其输出值相同
    String h1="abcdefg";
    System.out.println(h1.hashCode());
    String h2="abcdefg";
    System.out.println(h2.hashCode());
    System.out.println("============");
    // 特征2:输入了相似的数据,如果相差1Bit其输出结果也是大不同
    String h3="abcdefg";
    System.out.println(h3.hashCode());
    String h4="abcde1fg";
    System.out.println(h4.hashCode());
    System.out.println("==============");
    // 特征3:即使输入不同的值,输出相同的hash值会低概率形出现相同
    String str1="通话";
    System.out.println(str1.hashCode());
    String str2="重地";
    System.out.println(str2.hashCode());
    // 上面出现了Hash值的冲突
    // 特征4:哈希值不可逆的
    int i=96354;
    // 没有办法把此数字在逆向还原成“abc"
    // 特殊5:计算相对简单
    // MD5 SHA SHA-2
}

实例:

public static void main(String[] args) {
    // 创建Set集合
    HashSet<String> set=new HashSet<>();
    //添加元素
    set.add("abc");
    set.add("cda");
    set.add("bca");
    set.add("abc");
    for (String s : set) {
        System.out.println(s);
    }
}

根据结果我们发现了字符串“abc"存储一个,也就是说重复的元素在集合不存储=》自动去重

4.2 HashSet 存储自定义的类型元素

给HashSet存放自定义类型元素时,需要重写对象的hashCode和equals方法(建立了自己的比较方 式)

才能保证HashSet集合中自定义对象的唯一性

实例:

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
    Objects.equals(name, student.name);
}
@Override
public int hashCode() {
    return Objects.hash(name, age);
}
@Override
public String toString() {
    return "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +'}';
        }
}

public static void main(String[] args) {
    HashSet<Student> set=new HashSet();
    set.add(new Student("张三",23));
    set.add(new Student("李四",23));
    set.add(new Student("王五",23));
    set.add(new Student("张三",23));
    for (Student student : set) {
        //System.out.println(student.getName()+"/"+student.getAge());
        System.out.println(student);
    }
}

4.3 LinkedHashSet

我们知道HashSet保证元素是唯一的,可是元素存在进去没有顺序,如果要保证有序,怎么办哟 在HashSet下面有一个子类:java.util.LinkedHashSet,它是链表和哈希表组合一个数据存储结构

import java.util.Set;
import java.util.LinkedHashSet;
public class LinkedHashSetTest {
    public static void main(String[] args) {
        Set<String> set=new LinkedHashSet<String>();
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("ddd");
        set.add("eee");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

五、Collections 工具类

首先和Collection相区别,Collection是接口 Collections 是工具类

Collections集合工具类,用来对集合进行操作,提供很多工具方法

public class CollectionsDemo {
public static void main(String[] args) {
    ArrayList<Integer> list=new ArrayList<>();
    //list.add(1);
    Collections.addAll(list,51,22,33,44);
    System.out.println(list);
    //排序
    System.out.println("===================");
    Collections.sort(list);
    System.out.println(list);
    System.out.println("===================");
    //乱序
    Collections.shuffle(list);
    System.out.println(list);
}
}

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号