集合框架
集合概念:对象容器,实现了对对象常用的操作类似数组功能
和数组的区别:
(1)数组长度固定。集合长度不固定
(2)数组可以存储基本类型和引用类型,集合只能存储引用类型【装箱改变】
Collection体系集合
collection的使用
package 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.size());
// System.out.println(collection);
//3.遍历元素
//使用增强for
System.out.println("===================================");
System.out.println("使用增强for遍历");
for (Object o : collection) {
System.out.println(o);
}
//使用迭代器(迭代器专门用来遍历集合)
//hasNext 判断是否由下一个元素
//next 获取下一个元素
//remove 删除元素
System.out.println("使用迭代器遍历");
Iterator it=collection.iterator();
while (it.hasNext()){
String next = (String)it.next();
System.out.println(next);
//使用迭代器不允许使用命令删除 会破坏整体完整性
}
//判断
System.out.println(collection.contains("西瓜"));//判断是否有西瓜
System.out.println(collection.isEmpty());//判断集合是否为空
}
}
package Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//保存学生信息
public class Demo02 {
public static void main(String[] args) {
//实例化
Collection collection=new ArrayList();
//添加学生数据
Student s1=new Student("张三",19);
Student s2=new Student("张四",19);
Student s3=new Student("张五",19);
Student s4=new Student("张六",19);
collection.add(s1);
collection.add(s2);
collection.add(s3);
collection.add(s4);
System.out.println("元素个数:"+collection.size());
System.out.println(collection);
// collection.remove(s1);
// collection.clear();
// System.out.println("删除之后:"+collection.size());
//遍历
for (Object o : collection) {
System.out.println(o);
}
System.out.println("++++++++++++++++++++++++++++++++++");
Iterator iterator=collection.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
package Collection;
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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 +
'}';
}
}
List子接口
特点:有序,有下标,元素可以重复
LinkedList
package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* List子接口的使用
* 特点:有序,有下标,可以重复
*/
public class Demo03 {
public static void main(String[] args) {
//创建集合对象
List list=new ArrayList<>();
//添加元素
list.add("苹果");
list.add("西瓜");
list.add(0,"香蕉");
System.out.println("元素个数:"+list.size());
System.out.println(list);
//删除元素
// list.remove("香蕉");
// list.remove(0);
// System.out.println("元素个数:"+list.size());
// System.out.println(list);
//遍历
// for (Object o : list) {
// System.out.println(o);
// }
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
//迭代器遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//使用列表迭代器 和Iterator的区别 可以向前或向后遍历,可以添加元素和删除,修改
ListIterator listIterator = list.listIterator();
System.out.println("使用列表迭代器正向");
while (listIterator.hasNext()){
System.out.println(listIterator.nextIndex()+":"+listIterator.next());
}
System.out.println("逆向");
while (listIterator.hasPrevious()){
System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
}
//获取位置
System.out.println(list.indexOf("苹果"));
}
}
package Collection;
import java.util.ArrayList;
import java.util.List;
public class Demo04 {
public static void main(String[] args) {
//集合创建
List list=new ArrayList();
//数据添加 (自动装箱)
list.add(10);
list.add(20);
list.add(30);
list.add(40);
list.add(50);
System.out.println("元素个数:"+list.size());
System.out.println(list);
//删除
//list.remove(1);
//list.remove( (Object)20);
list.remove(new Integer(20));
System.out.println("元素个数:"+list.size());
//补充 sublist 返回子集合 含头不含尾
List list1 = list.subList(1, 3);
System.out.println(list1);
}
}
ArrayList数组结构实现,查询快,增删慢
源码分析:
默认容量DEFAULT_CAPACITY = 10
注意:如果没有向集合中添加元素容量为0
EMPTY_ELEMENTDATA 存放元素数组
size 实际元素个数
add 添加元素
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
Vector:
数组结构实现,查询快,增删慢
运行效率慢,线程安全
package Collection;
import java.util.Enumeration;
import java.util.Vector;
public class Demo06 {
public static void main(String[] args) {
//创建集合
Vector vector=new Vector();
vector.add("草莓");
vector.add("芒果");
vector.add("西瓜");
System.out.println("元素的个数:"+vector.size());
//删除
// vector.remove(0);
//遍历
//使用枚举器
Enumeration elements = vector.elements();
while (elements.hasMoreElements()){
Object o = elements.nextElement();
System.out.println(o);
}
}
}
LinkedList
链表结构,增删快,查询慢
package Collection.LinkedList;
import Collection.Student;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
/**
* LinkedList的使用
* 存储结构:双向链表
*/
public class Demo01 {
public static void main(String[] args) {
LinkedList<Object> objects = new LinkedList<>();
Student s1=new Student("刘德华",20);
Student s2=new Student("郭富城",20);
Student s3=new Student("梁朝伟",20);
objects.add(s1);
objects.add(s2);
objects.add(s3);
System.out.println("元素个数:"+objects.size());
System.out.println(objects.toString());
//删除
// objects.remove(0);
// objects.remove(s1);
//System.out.println("元素个数:"+objects.size());
//遍历
System.out.println("---------for--------------");
for (int i = 0; i <objects.size() ; i++) {
System.out.println(objects.get(i));
}
System.out.println("-------增强for--------------");
for (Object object : objects) {
System.out.println(object);
}
System.out.println("-------使用迭代器--------------");
Iterator<Object> iterator = objects.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("-------使用逆向迭代器--------------");
ListIterator<Object> objectListIterator = objects.listIterator();
while(objectListIterator.hasNext()){
System.out.println(objectListIterator.next());
}
}
}
ArrayList与LinkedList的区别
ArrayList:必须开辟连续空间,查询快,增删慢
LinkedList:无需开辟连续空间,查询慢,增删快
泛型
java泛型是JDK1.5中引入的一个性特性,其本质是参数化类型,把类型作为参数传递
常见形式有泛型类,泛型接口,泛型方法
语法:
<T……>T称为类型占位符,表示一种引用类型
好处:
1.提高代码的重用性
2.防止类型转化异常,提高代码安全性
泛型类
package 泛型;
/**
* 泛型类
* 语法:类名<T>
*T表示占位符,表示一种引用类型,可以写多个使用逗号分割
*/
public class Demo01<T> {
//使用泛型T
//创建变量
T t;
//添加方法,作为方法的参数
public void show(T t){
System.out.println(t);
}
//使用泛型作为方法的返回值
public T getT(){
return t;
}
}
package 泛型;
public class TestDemo01 {
public static void main(String[] args) {
//泛型只能是引用类型
//注意:不同泛型类之间不能相互复制
//使用泛型类创建对象
Demo01<String> demo01=new Demo01<>();//new Demo01<>();可以写,也可以不写
demo01.t="hello";
demo01.show("大家好");
System.out.println(demo01.getT());
Demo01<Integer> demo011=new Demo01<Integer>();
demo011.t=6;
demo011.show(9);
System.out.println(demo011.getT());
}
}
泛型接口
package 泛型;
/**
* 泛型接口
* 接口后面 接口名 <T>
* 注意:不能创建泛型静态常量
*/
public interface Demo02<T> {
String name="张三";
T server(T t);
}
package 泛型;
public class TestDemo02 implements Demo02<String>{
@Override
public String server(String s) {
System.out.println(s);
return s;
}
}
package 泛型;
public class TestDemo02_1<T> implements Demo02<T>{
@Override
public T server(T t) {
System.out.println(t);
return null;
}
}
package 泛型;
public class TestDemo01 {
public static void main(String[] args) {
//泛型只能是引用类型
//注意:不同泛型类之间不能相互复制
//使用泛型类创建对象
Demo01<String> demo01=new Demo01<>();//new Demo01<>();可以写,也可以不写
demo01.t="hello";
demo01.show("大家好");
System.out.println(demo01.getT());
Demo01<Integer> demo011=new Demo01<Integer>();
demo011.t=6;
demo011.show(9);
System.out.println(demo011.getT());
TestDemo02 testDemo02 = new TestDemo02();
testDemo02.server("你好");
TestDemo02_1 testDemo02_1=new TestDemo02_1<Integer>();
testDemo02_1.server(1);
}
}
泛型方法
package 泛型;
/**
* 泛型方法
* 语法<T>返回值类型
*
*/
public class Demo03 {
public <T> T show(T t){
System.out.println("泛型方法"+t);
return t;
}
}
package 泛型;
public class TestDemo03 {
public static void main(String[] args) {
Demo03 demo03 = new Demo03();
demo03.show("你好");
demo03.show(3.14);
demo03.show(8);
}
}
set接口
无序,无下标,元素不可重复
package set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* 测试set接口的使用
* 特点、;无序,没有下标,不重复
*/
public class Demo01 {
public static void main(String[] args) {
//创建集合
Set<String> set=new HashSet<>();
//添加数据
set.add("小米");
set.add("华为");
set.add("苹果");
System.out.println("数据个数:"+set.size());
System.out.println(set.toString());
//删除
// set.remove("华为");
// System.out.println("数据个数:"+set.size());
// System.out.println(set.toString());
//遍历
System.out.println("------增强for--------");
for (String s : set) {
System.out.println(s);
}
System.out.println("--------迭代器--------");
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
}
}
hash
package set;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
/**
* hashset集合的使用
* 存储结构:哈希表()数组+链表+红黑树
*/
public class Demo02 {
public static void main(String[] args) {
//创建集合
HashSet<String> hashMap=new HashSet<String>();
//添加元素
hashMap.add("刘德华");
hashMap.add("周润发");
hashMap.add("梁朝伟");
hashMap.add("周星驰");
System.out.println("个数"+hashMap.size());
System.out.println(hashMap.toString());
//删除
// hashMap.remove("梁朝伟");
// System.out.println("个数"+hashMap.size());
// System.out.println(hashMap.toString());
//遍历
System.out.println("------增强for----------");
for (String s : hashMap) {
System.out.println(s);
}
//迭代器
System.out.println("--------迭代器----------");
Iterator<String> iterator = hashMap.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//判断
System.out.println(hashMap.contains("郭富城"));
}
}
package set;
public class person {
String name;
int age;
public person(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 "person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int hashCode() {
int n1=this.name.hashCode();
int n2=this.age;
return n1+n2;
}
@Override
public boolean equals(Object obj) {
if(this==obj){
return true;
}
if (obj==null){
return false;
}
if (obj instanceof person){
person p=(person) obj;
if (this.name.equals(p.getName())&&this.age==p.getAge()){
return true;
}
}
return false;
}
}
package set;
import java.util.HashSet;
/**
* hashset的使用
*/
public class Demo03 {
public static void main(String[] args) {
HashSet<person> hashSet=new HashSet<>();
person p1=new person("李德华",18);
person p2=new person("王德华",18);
person p3=new person("张德华",18);
hashSet.add(p1);
hashSet.add(p2);
hashSet.add(p3);
System.out.println("个数"+hashSet.size());
System.out.println(hashSet.toString());
}
}
TreeSet
基于排序顺序实现元素不重复
实现了SortedSet接口,对集合元素自动排序
元素对象的类型必须实现Comparable接口,指定排序规则
红黑树
package set;
import java.util.TreeSet;
/**
* TreeSet使用
* 存储结构:红黑树
*
*/
public class Demo04 {
public static void main(String[] args) {
//创建集合
TreeSet<String> treeMap=new TreeSet<String>();
//添加元素
treeMap.add("xyz");
treeMap.add("abc");
treeMap.add("hello");
System.out.println("个数:"+treeMap.size());
System.out.println(treeMap.toString());
//
}
}
package set;
public class person implements Comparable<person>{
String name;
int age;
public person(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 "person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int hashCode() {
int n1=this.name.hashCode();
int n2=this.age;
return n1+n2;
}
@Override
public boolean equals(Object obj) {
if(this==obj){
return true;
}
if (obj==null){
return false;
}
if (obj instanceof person){
person p=(person) obj;
if (this.name.equals(p.getName())&&this.age==p.getAge()){
return true;
}
}
return false;
}
//先按姓名比再按年龄比
@Override
public int compareTo(person o) {
int n1=this.getName().compareTo(o.getName());
int n2=this.getAge()-o.getAge();
return n1==0?n2:n1;
}
}
package set;
import java.util.TreeSet;
/**
* 使用TreeSet存储数据
* 存储结构:红黑树
* 元素对象的类型必须实现Comparable接口
*/
public class Demo05 {
public static void main(String[] args) {
//创建集合
TreeSet<person> people=new TreeSet<>();
person p1=new person("李德华",18);
person p2=new person("王德华",18);
person p3=new person("张德华",18);
people.add(p1);
people.add(p2);
people.add(p3);
System.out.println(people.size());
System.out.println(people.toString());
}
}
package set;
import java.util.Comparator;
import java.util.TreeSet;
/**
* TreeSet集合的使用
* Comparator:实现定制比较(比较器)
*
*/
public class Demo06 {
public static void main(String[] args) {
TreeSet<person> treeSet=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("李德华",18);
person p2=new person("王德华",18);
person p3=new person("张德华",18);
treeSet.add(p1);
treeSet.add(p2);
treeSet.add(p3);
System.out.println(treeSet.size());
}
}
Map集合
package Map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* map接口的使用
* 存储的是键值对,键不可以,值可以重复,无序
*/
public class Demo01 {
public static void main(String[] args) {
//创建集合
Map<String,String> map=new HashMap<>();
//添加元素
map.put("cn","中国");
map.put("uk","英国");
map.put("usa","美国");
System.out.println("个数:"+map.size());
System.out.println(map.toString());
//删除
// map.remove("usa");
// System.out.println("个数:"+map.size());
//遍历
//使用Keyset
System.out.println("--------使用Keyset-----------");
Set<String> strings = map.keySet();
for (String string : strings) {
System.out.println(string+"-----------"+map.get(string));
}
//使用entryset方法
System.out.println("------使用entryset------");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry.getKey()+"----"+entry.getValue());
}
}
}