当前位置 : 主页 > 编程语言 > 其它开发 >

Java集合框架

来源:互联网 收集:自由互联 发布时间:2022-05-17
1.集合和数组的区别 数组长度是固定的,集合长度是可变的 数组可以存储基本类型和引用类型,集合只能存储引用类型 2.Collection体系集合 List接口的特点: 有序、有下标、元素可重复
1.集合和数组的区别
  • 数组长度是固定的,集合长度是可变的

  • 数组可以存储基本类型和引用类型,集合只能存储引用类型

2.Collection体系集合

List接口的特点:

有序、有下标、元素可重复

Set接口的特点:

无序、无下标、元素不能重复

2.1Collection父接口

特点:代表一组任意类型的对象,无序、无下标、不能重复

方法:

  • boolean add(Object obj) //添加一个对象

  • boolean addAll(Collection c) //将一个集合中的所有对象添加到此集合中

  • void clear() //清空此集合中的所有对象

  • boolean contains(Object o) //检查此集合中是否包含o对象

  • boolean equals(Object o) //比较此集合是否与指定对象相等

  • boolean isEmpty() //判断此集合是否为空

  • boolean remove(Object o) //在此集合中移除o对象

  • int size() //返回此集合中的元素个数

  • Object[] toArray() //将此集合转换成数组

collection操作:

package com.framework.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
Collection接口的使用
1。添加元素
2。删除元素
3。遍历元素
4。判断
*/
public class Demo01 {
   public static void main(String[] args) {
       //创建一个集合
       Collection collection new ArrayList();
       //1。添加元素
       collection.add("苹果");
       collection.add("榴莲");
       collection.add("香蕉");
       System.out.println("元素个数:" collection.size());
       System.out.println(collection);
       //2。删除元素
       collection.remove("榴莲");
       System.out.println("剩下的元素:" collection);
       System.out.println("===========================================");
       //清空 collection.clear();
       //3。遍历元素
       //增强for循环
       for (Object object: collection) {
           System.out.println(object);
      }
       System.out.println("===========================================");
       //使用迭代器(专门用于遍历集合的方式)
       //hasNext();有没有下一个元素
       //next();获取下一个元素
       //remove();删除当前元素
       Iterator it collection.iterator();
       while (it.hasNext()){
           String = (String) it.next();
           System.out.println(s);
           it.remove();
      }//迭代器迭代过程中不能使用collection删除方法删除元素
       System.out.println(collection.size());
       System.out.println("===========================================");
       //4。判断
       System.out.println(collection.contains("苹果"));
       System.out.println(collection.isEmpty());
  }
}
package com.framework.collection;

import org.w3c.dom.ls.LSOutput;

public class Student {
   private String name;
   private int age;

   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 String toString() {
       return "Student{" +
               "name='" name '\'' +
               ", age=" age +
               '}';
  }
}
package com.framework.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Demo02 {
   public static void main(String[] args) {
       //collection的使用
       //新建一个collection对象
       Collection collection new ArrayList();
       Student s1 new Student("zhangsan", 22);
       Student s2 new Student("zhao", 21);
       Student s3 new Student("wang", 20);
       //添加学生数据
       collection.add(s1);
       collection.add(s2);
       collection.add(s3);
       collection.add(s3);
       System.out.println("元素个数:" collection.size());
       System.out.println(collection.toString());
       //删除
       collection.clear();//对象和集合都在堆中,集合中储存的是对象的地址,删除是删除集合中的地址,对象还在
       System.out.println("删除之后:" collection.toString());
       //遍历
       //增强for
       System.out.println("==========================================");
       for (Object object: collection) {
           Student = (Student) object;
           System.out.println(s.toString());
      }
       System.out.println("==========================================");
       //迭代器
       Iterator it collection.iterator();
       while (it.hasNext()){
           Student = (Student) it.next();
           System.out.println(s.toString());
      }
       //判断
       System.out.println(collection.contains(s1));
       System.out.println(collection.isEmpty());
  }
}
3.List集合

特点:有序、有下标、元素可以重复

方法:

  • void add(int index,Object o) //在index位置插入对象o

  • boolean addAll(int index,Collection c) //将一个集合中的元素添加到此集合中的index位置

  • Object get(int index) //返回集合中指定位置的元素

  • List subList(int fromIndex , int toIndex) //返回fromIndex和toIndex之间的集合元素

package com.framework.list;

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

public class Demo01 {
   public static void main(String[] args) {
       //先创建集合对象
       List list new ArrayList();
       //添加元素
       list.add("手机");
       list.add("手表");
       list.add("电脑");
       System.out.println("元素的个数:" list.size());
       System.out.println(list.toString());
       //删除
       //list.remove("手机");
       list.remove(0);
       System.out.println("删除之后:" list.toString());
       //遍历
       //for
       for (int 0; list.size(); i++) {
           String = (String) list.get(i);
           System.out.println(s);
      }
       System.out.println("=========================");
       //增强for
       for (Object o : list) {
           System.out.println(o);
      }
       System.out.println("=========================");
       //迭代器
       Iterator it list.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
      }
       System.out.println("==========================");
       //使用列表迭代器,和Iterator区别
       //listIterator可以向前或向后遍历,添加,删除,修改元素
       ListIterator lit list.listIterator();
       System.out.println("=============使用列表迭代器从前往后=================");
       while (lit.hasNext()){
           System.out.println(lit.nextIndex() ":" lit.next());
      }
       System.out.println("=============使用列表迭代器从后往前=================");
       while (lit.hasPrevious()){
           System.out.println(lit.previousIndex() ":" lit.previous());
      }
       System.out.println("============================");
       //判断
       System.out.println(list.contains("电脑"));
       System.out.println(list.isEmpty());
       System.out.println("============================");
       //获取位置
       System.out.println(list.indexOf("手表"));
  }
}
package com.framework.list;

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

public class Demo02 {
   public static void main(String[] args) {
       //创建集合
       List list new ArrayList();
       //添加数字数据(自动装箱,int变成integer)
       list.add(20);
       list.add(30);
       list.add(40);
       list.add(50);
       list.add(60);
       list.add(70);
       System.out.println("元素个数:" list.size());
       System.out.println(list.toString());
       //删除
       list.remove((Integer)20);
       System.out.println("删除元素:" list.size());
       System.out.println(list.toString());
       //subList方法,返回子集合,含头不含尾
       List subList list.subList(1, 3);
       System.out.println(subList.toString());
  }
}
3.1List实现类 3.1.1ArrayList
  • 数组结构实现,查询快,增删慢

  • 运行效率快、线程不安全

ArrayList默认容量

  • DEFAULT_CAPACITY =10,默认容量为10

  • elementData存放元素的数组

  • size 实际的元素个数<=容量

  • 如果没有向集合中添加任何元素时,容量为0,添加任意一个元素之后,容量变为10,每次扩容大小是原来的1.5倍

ArrayList

package com.framework.ArrayList;

import com.framework.collection.Student;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo01 {
   public static void main(String[] args) {
       //创建集合
       ArrayList arrayList new ArrayList();
       //添加
       Student s1 new Student("刘德华",21);
       Student s2 new Student("周杰伦",21);
       Student s3 new Student("陈奕迅",21);
       arrayList.add(s1);
       arrayList.add(s2);
       arrayList.add(s3);
       System.out.println("元素个数:" arrayList.size());
       System.out.println(arrayList.toString());
       //删除
       //arrayList.remove(new Student("刘德华", 21));//equals(this == obj)
       //System.out.println("删除之后:" + arrayList.toString());
       //遍历,迭代器
       System.out.println("=======================================");
       Iterator it arrayList.iterator();
       while (it.hasNext()){
           Student = (Student) it.next();
           System.out.println(s.toString());
      }
       System.out.println("================列表迭代器=======================");
       ListIterator lit arrayList.listIterator();
       while (lit.hasNext()){
           Student = (Student) lit.next();
           System.out.println(s.toString());
      }
       System.out.println("================逆序=======================");
       while (lit.hasPrevious()){
           Student = (Student) lit.previous();
           System.out.println(s.toString());
      }
       //判断
       System.out.println("=======================================");
       System.out.println(arrayList.contains(new Student("刘德华", 21)));
       System.out.println(arrayList.isEmpty());
       //查找
       System.out.println("=======================================");
       System.out.println(arrayList.indexOf(new Student("刘德华", 21)));
  }
}

重写equals方法

@Override
   public boolean equals(Object o) {
       //判断是不是同一个对象
       if (this == o) {
           return true;
      }
       //判断是否为空
       if (== null) {
           return false;
      }
       //判断是否是Student类型
       if (instanceof Student){
           Student = (Student) o;
           //比较属性
           if (this.name.equals(s.getName())&&this.age == s.getAge()){
               return true;
          }
      }
       //不满足返回false
       return false;
  }

 

3.1.2Vector
  • 数组结构实现,查询快,增删慢

  • 运行效率慢、线程安全

package com.framework.vector;

import java.util.Enumeration;
import java.util.Vector;

public class Demo01 {
   public static void main(String[] args) {
       //创建集合
       Vector vector new Vector();
       //添加元素
       vector.add("草莓");
       vector.add("芒果");
       vector.add("西瓜");
       //打印
       System.out.println("元素个数:" vector.size());
       System.out.println(vector.toString());
       //删除
//       vector.remove(0);
//       vector.remove("西瓜");
//       vector.clear();
       //使用枚举器遍历
       Enumeration elements vector.elements();
       while (elements.hasMoreElements()){
           String = (String) elements.nextElement();
           System.out.println(s);
      }
       //判断
       System.out.println(vector.contains("西瓜"));
       System.out.println(vector.isEmpty());
       //vector其他方法
//       vector.firstElement();
//       vector.lastElement();
//       vector.elementAt();

  }
}

 

3.1.3LinkedList
  • 链表结构实现,增删快,查询慢

LinkedList

  • 存储结构:双向链表

package com.framework.linkedlist;

import com.framework.collection.Student;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class Demo01 {
public static void main(String[] args) {
//创建集合
LinkedList linkedList = new LinkedList();
//添加元素
Student s1 = new Student("橘猫", 22);
Student s2 = new Student("蓝猫", 21);
Student s3 = new Student("大花猫", 20);

linkedList.add(s1);
linkedList.add(s2);
linkedList.add(s3);

System.out.println("元素个数:" + linkedList.size());
System.out.println(linkedList.toString());
//删除
linkedList.remove(s1);
System.out.println("删除之后:" + linkedList.size());
System.out.println(linkedList.toString());
//遍历
System.out.println("=================for===================");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
System.out.println("=================增强for===================");
for (Object o: linkedList) {
Student s = (Student) o;
System.out.println(s.toString());
}
System.out.println("=================迭代器===================");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()){
Student s = (Student) iterator.next();
System.out.println(s.toString());
}
System.out.println("=================list迭代器===================");
ListIterator listIterator = linkedList.listIterator();
while (listIterator.hasNext()){
Student s = (Student) listIterator.next();
System.out.println(s.toString());
}
//从后往前
while (listIterator.hasPrevious()){
Student s = (Student) listIterator.previous();
System.out.println(s.toString());
}
//判断
System.out.println(linkedList.contains(s1));
System.out.println(linkedList.isEmpty());
//获取
System.out.println(linkedList.indexOf(s1));
}
}

ArrayList和LinkedList区别:

  • ArrayList必须开辟连续空间,查询快,增删慢

  • LinkedList无需开辟连续空间,查询慢,增删快

4.泛型

常见形式有泛型类、泛型接口、泛型方法

语法:

<T,...> T称为类型占位符,表示一种引用类型

好处:

  • 提高代码的重用性

  • 防止类型转换异常,提高代码的安全性

4.1泛型类
package com.framework.MyGeneric;

//泛型类 T表示一种引用类型,如果写多个,用逗号隔开
public class MyGenericDemo01<T> {

//使用泛型T创建变量
T t;
//作为方法的参数
public void show(T t){
//不能实例化(不能new)
System.out.println(t);
}
//使用泛型作为方法的返回值
public T getT(){
return t;
}

}

 

package com.framework.MyGeneric;

public class TestGeneric {
public static void main(String[] args) {
//使用泛型类创建对象
//1。泛型只能使用引用类型
//2。不同泛型类型对象之间不能相互赋值
MyGenericDemo01<String > myGeneric = new MyGenericDemo01<String>();
myGeneric.t = "hello";
myGeneric.show("大家好");
String t = myGeneric.getT();

MyGenericDemo01<Integer> myGeneric2 = new MyGenericDemo01<Integer>();
myGeneric2.t = 100;
myGeneric2.show(200);
Integer integer = myGeneric2.getT();
}
}
4.2泛型接口
package com.framework.MyGeneric;

//泛型接口
public interface MyInterface<T> {
String name = "zhangsan";

//不能创建泛型静态常量
T server(T t);

}
package com.framework.MyGeneric;

public class MyInterfaceImpl implements MyInterface<String> {
@Override
public String server(String s) {
System.out.println(s);
return s;
}

}
package com.framework.MyGeneric;

public class TestGeneric {
public static void main(String[] args) {

MyInterfaceImpl impl = new MyInterfaceImpl();
impl.server("xxxxx");

MyInterfaceImpl2<Integer> impl2 = new MyInterfaceImpl2<>();
impl2.server(1000);
}
}
4.3泛型方法
package com.framework.MyGeneric;

//泛型方法
//语法:<T> 返回值类型
public class MyGenericMethod {
//泛型方法
public <T> void show(T t){
System.out.println("泛型方法:" + t);
}
}
package com.framework.MyGeneric;

public class TestGeneric {
public static void main(String[] args) {

//泛型方法
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("张三");
}
}
4.4泛型集合

概念:参数化类型、类型安全的集合,强制集合元素的类型必须一致

特点:

  • 编译时检查,而非运行时抛出异常

  • 访问时,不必类型转换

  • 不同泛型之间引用不能相互赋值,泛型不存在多态

package com.framework.MyGeneric;

import com.framework.collection.Student;

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

public class Demo01 {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("xxxx");
arrayList.add("yyyy");
//arrayList.add(20);
//arrayList.add(30);
for (String s:
arrayList) {
System.out.println(s);
}

ArrayList<Student> arrayList1 = new ArrayList<Student>();
Student s1 = new Student("肥肥", 21);
Student s2 = new Student("甜甜", 24);
Student s3 = new Student("猪猪", 22);
arrayList1.add(s1);
arrayList1.add(s2);
arrayList1.add(s3);
Iterator<Student> iterator = arrayList1.iterator();
while (iterator.hasNext()){
Student next = iterator.next();
System.out.println(next);
}

}
}
5.Set子接口

特点:无序、无下标、元素不可重复

方法:全部继承自collection中的方法

5.1Set实现类 5.1.2HashSet
  • 基于HashSet计算元素存放位置

  • 当存入元素的哈希码相同时,会调用equals进行确认,如果结果为true,则拒绝后者存入

 

package com.framework.set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

//测试Set接口的使用
public class SetInterfaceDemo01 {
public static void main(String[] args) {
//创建集合
Set<String> set = new HashSet<>();
//添加数据
set.add("苹果");
set.add("小米");
set.add("华为");
set.add("华为");
set.add("荣耀");
System.out.println("元素个数:" + set.size());
System.out.println(set.toString());
//删除
set.remove("华为");
System.out.println(set.toString());
//遍历(1.增强for2.迭代器)
System.out.println("=====================增强for=====================");
for (String s:
set) {
System.out.println(s);
}
System.out.println("=====================迭代器======================");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
//判断
System.out.println(set.contains("华为"));
System.out.println(set.isEmpty());
}
}
package com.framework.set;

import java.util.Objects;

public class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

// @Override
// public boolean equals(Object o) {
// if (this == o) {
// return true;
// }
// if (o == null ) {
// return false;
// }
// if (o instanceof Person){
// Person p = (Person) o;
// if (this.name.equals(p.getName())&&this.age == p.getAge()){
// return true;
// }
// }
// return false;
// }
//
// @Override
// public int hashCode() {
// int n1 = this.name.hashCode();
// int n2 = this.age;
// return n1+n2;
// }

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
package com.framework.set;

import java.util.HashSet;
import java.util.Iterator;

/*存储过程:
1.根据hashcode计算保存的位置,如果此位置为空,则直接保存,如果不为空执行第二步
2.再执行equals方法,如果equals方法为true,则认为是重复,否则,形成链表
*/

public class Demo03 {
public static void main(String[] args) {
//新建集合
HashSet<Person> person = new HashSet<>();
Person p1 = new Person("肥肥", 21);
Person p2 = new Person("猪猪", 24);
Person p3 = new Person("侠侠", 23);
Person p4 = new Person("甜甜", 22);
person.add(p1);
person.add(p2);
person.add(p3);
person.add(p4);
person.add(new Person("甜甜", 22));
System.out.println("元素个数:" + person.size());
System.out.println(person.toString());
//删除
//System.out.println(person.remove(new Person("侠侠", 23)));
//System.out.println(person.remove(p3));
//遍历
System.out.println("====================增强for====================");
for (Person p:
person) {
System.out.println(p);
}
System.out.println("====================迭代器====================");
Iterator<Person> iterator = person.iterator();
while (iterator.hasNext()){
Person next = iterator.next();
System.out.println(next);
}
//判断
System.out.println(person.contains(p1));
System.out.println(person.contains(new Person("侠侠", 23)));
}
}
5.1.3TreeSet
  • 基于排列顺序实现元素不重复

  • 实现了SortedSet接口,对集合元素的自动排序

  • 元素对象的类型必须实现Comparable接口,指定排序规则

  • 通过ComparaTo方法确定是否为重复元素

package com.framework.set.treeset;

import java.util.Iterator;
import java.util.TreeSet;

//存储结构:红黑树
public class Demo01 {
public static void main(String[] args) {
//创建集合
TreeSet<String> treeSet = new TreeSet<>();
//添加元素
treeSet.add("ddd");
treeSet.add("aaa");
treeSet.add("ccc");
treeSet.add("bbb");
treeSet.add("bbb");
System.out.println("元素个数:" + treeSet.size());
System.out.println(treeSet.toString());
//删除
treeSet.remove("aaa");
System.out.println(treeSet.toString());
//遍历
System.out.println("====================增强for===================");
for (String s: treeSet) {
System.out.println(s);
}
System.out.println("====================迭代器===================");
Iterator<String> iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println(treeSet.contains("aaa"));
}
}

 

package com.framework.set.treeset;

import java.util.Objects;

public class Person implements Comparable<Person>{
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

// @Override
// public boolean equals(Object o) {
// if (this == o) {
// return true;
// }
// if (o == null ) {
// return false;
// }
// if (o instanceof Person){
// Person p = (Person) o;
// if (this.name.equals(p.getName())&&this.age == p.getAge()){
// return true;
// }
// }
// return false;
// }
//
// @Override
// public int hashCode() {
// int n1 = this.name.hashCode();
// int n2 = this.age;
// return n1+n2;
// }

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}

//先比姓名,再比年龄
@Override
public int compareTo(Person o) {
int n1 = this.getName().compareTo(o.getName());
int n2 = this.age - o.getAge();
return n1==0?n2:n1;
}
}
package com.framework.set.treeset;

import com.framework.set.treeset.Person;

import java.util.Iterator;
import java.util.TreeSet;

/*
使用TreeSet保存数据

要求:元素必须要实现Comparable接口,comparaTo()方法返回值为0,认为是重复元素
*/
public class Demo02 {
public static void main(String[] args) {
//创建集合
TreeSet<Person> person = new TreeSet<>();
Person p1 = new Person("bbb", 21);
Person p2 = new Person("aaa", 24);
Person p3 = new Person("ddd", 23);
Person p4 = new Person("ccc", 22);
Person p5 = new Person("ddd", 26);
Person p6 = new Person("ddd", 26);
person.add(p1);
person.add(p2);
person.add(p3);
person.add(p4);
person.add(p5);
person.add(p6);
System.out.println("元素个数:" + person.size());
System.out.println(person.toString());
//删除
// System.out.println(person.remove(p1));
// System.out.println(person.remove(new Person("ddd", 26)));
// System.out.println(person.toString());
//遍历
System.out.println("====================增强for===================");
for (Person p: person) {
System.out.println(p);
}
System.out.println("====================迭代器===================");
Iterator<Person> iterator = person.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println(person.contains(p1));
System.out.println(person.contains(new Person("ddd", 26)));
}
}
package com.framework.set.treeset;

import java.util.Comparator;
import java.util.TreeSet;

/*treeset集合的使用
Comparator:实现定制比较(比较器)
Comparable:可比较的
*/
public class Demo03 {
public static void main(String[] args) {
//创建集合,并指定比较规则(匿名内部类,无须让person实现Comparable接口)
TreeSet<Person> person = new TreeSet<>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
int n1 = o1.getAge() - o2.getAge();
int n2 = o1.getName().compareTo(o2.getName());
return n1==0?n2:n1;
}
});
Person p1 = new Person("bbb", 21);
Person p2 = new Person("aaa", 24);
Person p3 = new Person("ddd", 23);
Person p4 = new Person("ccc", 22);
Person p5 = new Person("ddd", 26);
Person p6 = new Person("zzz", 26);
person.add(p1);
person.add(p2);
person.add(p3);
person.add(p4);
person.add(p5);
person.add(p6);
System.out.println("元素个数:" + person.size());
System.out.println(person.toString());
}
}
package com.framework.set.treeset;

import java.util.Comparator;
import java.util.TreeSet;

/*
使用treeSet集合实现字符串按照长度进行排序
*/
public class Demo04 {
public static void main(String[] args) {
TreeSet<String> s = new TreeSet<>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
int n1 = o1.length() - o2.length();
int n2 = o1.compareTo(o2);
return n1==0?n2:n1;
}
});
s.add("helloword");
s.add("zhangsan");
s.add("lisi");
s.add("xian");
s.add("nanjing");
s.add("cat");
System.out.println("元素个数:" + s.size());
System.out.println(s.toString());
}
}
6.Map体系集合

Map接口的特点:

  • 用于存储任意键值对(Key-Value)

  • 键:无序、无下标、不允许重复

  • 值:无序、无下标、允许重复

6.1Map父接口

Map接口的使用

package com.framework.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
Map接口的使用
特点:1.存储键值对2.键不能重复,值可以重复3.无序
*/
public class Demo01 {
public static void main(String[] args) {
//创建集合
Map<String, String> map = new HashMap<>();
//添加元素
map.put("cn","中国");
map.put("up","英国");
map.put("usa","美国");
map.put("cn1","中国");
System.out.println("元素个数:" + map.size());
System.out.println(map.toString());
//删除
map.remove("cn1");
System.out.println(map.toString());
//遍历
System.out.println("====================keySet=====================");
//Set<String> keySet = map.keySet();
//增强for
for (String s: map.keySet()) {
System.out.println(s+": "+map.get(s));
}
System.out.println("====================entrySet===================");
//Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String,String> entry: map.entrySet()) {
System.out.println(entry.getKey()+": "+entry.getValue());
}
}
}
6.2Map集合的实现类

HashMap

  • 线程不安全,运行效率快,允许用null作为key或是value

package com.framework.map;



import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
HashMap集合的使用
存储结构:哈希表
*/
public class HashMapDemo {
public static void main(String[] args) {
//创建集合
HashMap<Student, String> students = new HashMap<>();
//添加元素
Student s1 = new Student("赵", 12345);
Student s2 = new Student("王",12344);
Student s3 = new Student("李",12343);
students.put(s1,"北京");
students.put(s2,"郑州");
students.put(s3,"周口");
students.put(new Student("李",12343),"杭州");
System.out.println("元素个数:" + students.size());
System.out.println(students.toString());
//删除
students.remove(s1);
System.out.println(students.size());
//遍历
System.out.println("====================keySet=====================");
for (Student s: students.keySet()) {
System.out.println(s+": "+students.get(s));
}
System.out.println("====================entrySet===================");
Set<Map.Entry<Student, String>> entries = students.entrySet();
for (Map.Entry<Student,String> stu: entries) {
System.out.println(stu.getKey() + ": " + stu.getValue());
}
//判断
System.out.println(students.containsKey(s1));
System.out.println(students.containsKey(new Student("李",12343)));
System.out.println(students.containsValue("杭州"));
}
}

HashTable

  • Properties是HashTable是子类,要求key和value都是String。通常用于配置文件的读取

TreeMap

  • 实现了SortedMap接口(是Map的子接口),可以对key自动排序

package com.framework.map;

import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class TreeMapDemo {
public static void main(String[] args) {
//创建集合
TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int i = o1.getStuNo() - o2.getStuNo();
return i;
}
});
Student s1 = new Student("赵", 12345);
Student s2 = new Student("王",12344);
Student s3 = new Student("李",12343);
treeMap.put(s1,"北京");
treeMap.put(s2,"深圳");
treeMap.put(s3,"杭州");
treeMap.put(new Student("李",12343),"南京");
System.out.println("元素个数:" + treeMap.size());
System.out.println(treeMap.toString());
//删除
//treeMap.remove(s3);
//treeMap.remove(new Student("李",12343));
System.out.println(treeMap.size());
//遍历
System.out.println("====================keySet=====================");
for (Student student: treeMap.keySet()) {
System.out.println(student.toString()+"="+treeMap.get(student));
}
System.out.println("====================entrySet===================");
for (Map.Entry<Student,String> entry : treeMap.entrySet()) {
System.out.println(entry.toString());
}
//判断
System.out.println(treeMap.containsKey(s1));
System.out.println(treeMap.containsValue("南京"));
System.out.println(treeMap.containsKey(new Student("李",12343)));
}
}
7.Collections工具类

集合工具类,定义了除了存取以外的集合常用方法

package com.framework.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo01 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(20);
list.add(5);
list.add(10);
list.add(30);
list.add(50);
//sort排序
System.out.println("排序之前"+list.toString());
Collections.sort(list);
System.out.println("排序之后"+list.toString());
//binarySearch(二分查找)
System.out.println("=================================");
int i = Collections.binarySearch(list, 24);
System.out.println(i);
//copy复制
System.out.println("=================================");
ArrayList<Integer> arrayList = new ArrayList<>();
for (int j = 0; j < list.size(); j++) {
arrayList.add(0);
}
Collections.copy(arrayList,list);
System.out.println(arrayList.toString());
//reverse反转
System.out.println("=================================");
Collections.reverse(arrayList);
System.out.println(arrayList.toString());
//shuffle 打乱
System.out.println("=================================");
Collections.shuffle(arrayList);
System.out.println(arrayList.toString());
//list集合转成数组
System.out.println("=================================");
Integer[] arr = list.toArray(new Integer[0]);
System.out.println(arr.length);
System.out.println(Arrays.toString(arr));
//数组转成集合
System.out.println("=================================");
String[] names = {"zhangsan","lisi","wangwu"};
//数组转成集合之后,集合是受限集合,不能添加和删除
List<String> list1 = Arrays.asList(names);
System.out.println(list1.toString());

System.out.println("=================================");
//基本类型数据转成集合,不能用int,需要修改为引用类型
Integer[] nums = {100, 200, 300, 400, 500};
List<Integer> list2 = Arrays.asList(nums);
System.out.println(list2.toString());
}
}
8.Properties

Properties:属性集合

特点:

  • 存储属性名和属性值

  • 属性名和属性值都是字符串类型

  • 没有泛型

  • 和流有关

package com.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
* 演示Properties集合的使用
*/
public class PropertiesDemo {
public static void main(String[] args) throws Exception {
//创建集合
Properties properties = new Properties();
//添加数据
properties.setProperty("username","张三");
properties.setProperty("age","20");
System.out.println(properties.toString());
//遍历
System.out.println("===================keySet==================");
Set<Object> objects = properties.keySet();
for (Object o: objects) {
System.out.println(o.toString() + ": " + properties.get(o));
}
System.out.println("===================entrySet==================");
for (Map.Entry<Object, Object> o : properties.entrySet()) {
System.out.println(o.getKey() + ": " + o.getValue());
}
System.out.println("===================stringPropertyNames()==================");
Set<String> strings = properties.stringPropertyNames();
for (String s: strings) {
System.out.println(s + ": " + properties.getProperty(s));
}
//和流有关的方法
// System.out.println("===================list方法==================");
// PrintWriter pw = new PrintWriter("/Users/zhaoliang/IdeaProjects/io流/a1.txt");
// properties.list(pw);
// pw.close();
System.out.println("===================store方法 保存==================");
FileOutputStream fos = new FileOutputStream("/Users/zhaoliang/IdeaProjects/io流/a2.txt");
properties.store(fos,"注释");
fos.close();
System.out.println("===================load方法 加载==================");
FileInputStream fis = new FileInputStream("/Users/zhaoliang/IdeaProjects/io流/a2.txt");
properties.load(fis);
fis.close();
System.out.println(properties.toString());
}
}
9.面试题

List<Map<String,String>>遍历

package com.framework;

import java.util.*;

//List<Map<String,String>>遍历
public class Test {
public static void main(String[] args) {
List<Map<String, String>> listMaps = new ArrayList<Map<String, String>>();

Map<String, String> map1 = new HashMap<String, String>();
map1.put("aaa", "111");
map1.put("bbb", "222");
map1.put("ccc", "333");
listMaps.add(map1);

Map<String, String> map2 = new HashMap<String, String>();
map2.put("11", "aa");
map2.put("22", "bb");
map2.put("33", "cc");
listMaps.add(map2);

//方式1:
for (Map<String, String> map : listMaps) {
for (String s : map.keySet()) {
System.out.print(map.get(s) + " ");
}
}
System.out.println();
System.out.println("-----------------------------");

//方式2:
for (int i = 0; i < listMaps.size(); i++) {
Map<String, String> map = listMaps.get(i);
Iterator iterator = map.keySet().iterator();
while (iterator.hasNext()) {
String string = (String) iterator.next();
System.out.println(map.get(string));
}
}
System.out.println("-----------------------------");

//方式3:
for (Map<String, String> map : listMaps) {
for (Map.Entry<String, String> m : map.entrySet()) {
System.out.print(m.getKey() + " ");
System.out.println(m.getValue());
}
}
System.out.println("-----------------------------");
}

}

 

 

 

 

 

 

 

 

 

 

 

 

上一篇:数仓建模—埋点设计与管理
下一篇:没有了
网友评论