专业电子商务网站建设,番禺 网站建设,深圳建设局网站查询,wordpress书库插件集合Collection
一.概述
集合可以理解为数据结构的封装,根据不同的特性及操作性能进行分类
二.继承体系 三.Collection中常用方法
collection是集合中的父类,所以collection中的方法是所有集合中都有的 集合中只能保存引用类型(Object),无法保存基本类型 Colle…集合Collection
一.概述
集合可以理解为数据结构的封装,根据不同的特性及操作性能进行分类
二.继承体系 三.Collection中常用方法
collection是集合中的父类,所以collection中的方法是所有集合中都有的 集合中只能保存引用类型(Object),无法保存基本类型 Collection 中并没有查询和修改操作 判断是否为空 isEmpty(); Collection c new ArrayList();
c.isEmpty();添加 add c.add();删除 remove 根据内容删除元素 c.remove(a);已有元素个数 size() c.size();是否包含某个元素 contains() c.contains(1);清空集合元素 clean() c.clean();转换为数组 toArray() Object[] arr c.toArray();四.迭代器
4.1 概述
迭代器模式∶它可以使对于序列的底层数据结构的遍历行为与被遍历的对象分离,可以让我们无序关心底层数据结构直接的差异性,提供了统一遍历的标准.(无论底层为何种数据结构都可以使用这个标准进行遍历)
4.2 常用方法
注意 : 迭代器一旦生成,集合不能进行修改,除非重新生成迭代器,也就意味着,在迭代器中删除,只能使用迭代器的remove 不能使用集合的remove hashNext : 判断是否还有元素(boolean) next : 光标向下移动一位,并返回指向的数据 remove : 删除当前指向的元素
4.3 forEach
增强for循环foreach是 jdk5.0引入的 语法 会把集合中的每个数据,依次赋值给变量
for(数据类型变量名∶集合){
}是迭代器iterator的简写方式,如果只是需要做基本的遍历操作,就可以使用使用foreach 但是如果想要做删除操作,还是要使用iterator的,因为foreach无法进行删除操作
public static void main(String[] args){Collection c new ArrayList();c.add(1);c.add(a);c.add(3);for (Object object : c) {System.out.println(object);}
}五.List
有序(添加和取出顺序一致) 可重复(可以添加重复数据)
5.2 ArrayList
随机性添加和删除效率较低,查询和修改效率较高
//默认容量为10,每次扩容扩大1.5倍
//创建对象时容量为0,第一次添加数据的时候,长度初始化为10;
ArrayList arr new ArrayList();
// 尾部添加
arr.add(1);
// 指定位置添加,把数据2添加到第0位上
arr.add(0,2);//获取 根据下标查询数据
arr.get(0);//修改
arr.set(1,12);//根据内容删除
arr.remove(a);
//传入int,则为根据索引删除
arr.remove(0);
//假如我们要根据内容删除,而这个内容恰好是数字,则需要封装包装类
arr.remove(Integer.valueOf(12));//遍历
for(int i 0; i arr.size(); i){System.out.print(arr.get(i) );
}
for(Object object : arr){System.out.print(object);
}5.3 LinkedList
5.3.1 概述
LinkedList : 底层是一个双向链表,随机性添加和删除效率较高,查询和修改效率较低
5.3.2 使用方法
基本上和ArrayList的使用是一样的
LinkedList arr new LinkedList();
// 尾部添加
arr.add(1);
arr.add(a);
// 添加到指定位置,把数据2 添加到第0位上
arr.add(0, 2);
// 尾部添加
arr.addLast(4);
arr.offerLast(4);
arr.offer(6);
// 首位添加
arr.push(2);
arr.addFirst(4);
arr.offerFirst(5);
// 核心的添加方法 linkLast 和 linkFirst// 获取 根据下标查询数据
System.out.println(arr.get(0));
// 修改 把下标1的值换成12
arr.set(1, 12);// 根据内容删除
arr.remove(a);
// 传入int,则为根据索引删除
arr.remove(0);
// 假如我们要根据内容删除,而这个内容恰好是数字,则需要封装包装类
arr.remove(Integer.valueOf(12));
System.out.println(arr);arr.add(1);
arr.add(12);
arr.add(31);
arr.add(3);
arr.add(5);
for (int i 0; i arr.size(); i) {System.out.println(arr.get(i));
}
for (Object object : arr) {System.out.println(object);
}
5.3.3 Get方法实现理念 链表是不支持下标的,只是提供了类似于下标的操作方式,但是本质还是利用循环,一个一个去找,跟数组的下标访问压根不是一回事儿
5.3.4 linkedList类 5.3.5 Node节点类 5.3.6 添加底层实现 5.3.7 删除 六.set
6.1 特性
无序 : 不保证有序, 可能有序, 可能无序 不可重复 : 不能添加重复数据 不能做修改和查询操作
6.2 TreeSet
6.2.1 特征
底层是红黑树,添加的元素会按照特定的顺序进行排序 数字 : 从小到大 日期 : 自然日期 字符串 : 按照每位的ASCII码值进行排序 既然会排序,说明一定会进行比较不同类型是没有可比性的,因此treeSet必须保存同一类型
6.2.2 使用
没有查询和修改功能
TreeSet ts new TreeSet);
//添加
ts.add(1);
ts.add(12);
ts.add(3);
ts.add(9);
//java.lang.ClassCastException: java.lang.Integer cannot be cast toll java.lang.String
// ts.add(aa);
//根据内容删除
ts.remove(2);
//没有查询和修改功能
ts.size();
ts.isEmpty();
ts.contains(2);
ts.clear();
System.out.println(ts);6.2.3 注意
TreeSet set new TreeSet();
set.add(1);
set.add(7);
//没有重复数据
set.add(1);
//先比较第一位,按位比较
set.add(14);
set.add(16);
set.add(6);
System.out.print(set);//1 14 16 6 7;6.3 HashSet
6.3.1 概述
底层是Haspmap,set其实就是map的key部分,因此不能做查询和修改操作
七.排序
7.1 comparable
为什么会自动排序呢?因为添加的这些对象的类,都实现了Comparable接口,并实现了compareTo方法 要排序的类会根据compareTo方法的返回值,进行排序 返回0说明相等,就不添加 返回小于0的值,就说明要添加的元素比集合中的小,就会被放到前面 返回大于0的值,就说明要添加的元素比集合中的大,就会被放到后面 因此我们自定义的类想要被排序,就要实现comparable接口并覆写compareTo方法
public class Test_01 {public static void main(String[] args) {TreeSet ts new TreeSet();ts.add(new User(18, 张三));ts.add(new User(16, 张三));ts.add(new User(19, 张三));ts.add(new User(15, 张三));for (Object object : ts) {System.out.println(object);} }
}
class User implements Comparable{Overridepublic int compareTo(Object o) {if(o instanceof User){User user (User) o;return user.age - this.age;}return 0;}private int age;private String name;public User(int age, String name) {super();this.age age;this.name name;}public User() {super();}Overridepublic String toString() {return User [age age , name name ];}
}7.2 comparator
数字会默认从小到大排序,那么如果我们的需求是,要求数字从大到小排序呢? 数字升序是因为Integer类中有compareTo方法,并定义了升序排序,而我们并没有办法去修改Integer类中的源码,但是我们可以扩展Comparator:比较器类,当comparable和comparator同时存在的时候.comparator优先级大于comparable 应用场景︰ 如果保存的元素的类,是我们写的,肯定要实现comparable接口 如果保存的元素的类,不是我们写的,并且排序规则也无法满足我们的需求,需要使用comparator来进行扩展
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;class User implements ComparatorUser {private String name;private int age;private boolean sex;public User() {}public User(String name, int age, boolean sex) {this.name name;this.age age;this.sex sex;}Overridepublic String toString() {return User{ name name \ , age age , sex sex };}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;}public boolean isSex() {return sex;}public void setSex(boolean sex) {this.sex sex;}Overridepublic int compare(User o1, User o2) {return o1.age-o2.age;}
}
public class Test{public static void main(String[] args) {User user1new User(dingli,25,true);User user2new User(huxiaojuan,24,false);User user3new User(xxx,24,false);ListUser listnew ArrayListUser();list.add(user1);list.add(user2);list.add(user3);Collections.sort(list, new User()); //类实现了的Comparator能满足需求System.out.println(类自身实现Comparator:list);//现在我想要按照名字升序显然类中实现的不能满足要求于是可以在类外自己实现想要的比较器Collections.sort(list, new ComparatorUser() {Overridepublic int compare(User o1, User o2) {return o1.getName().compareTo(o2.getName()); //按照名字升序}});System.out.println(匿名内部类方式list);//由于Comparator接口是一个函数式接口因此根据jdk1.8新特性我们可以采用Lambda表达式简化代码Collections.sort(list,(u1,u2)-{return u1.getName().compareTo(u2.getName());});System.out.println(Lambda表达式方式list);}
}7.3 Collections
Collections.sort() 方法是用于对 List 集合中的元素进行排序的。这个方法有两个重载版本一个接受一个 List 参数要求列表中的元素实现了 Comparable 接口另一个接受一个 List 参数和一个 Comparator 参数允许你指定一个自定义的比较器。
public static void main(String[] args) {ArrayList al new ArrayList();al.add(1);al.add(16);al.add(5);al.add(2);al.add(7);Collections.sort(al);System.out.println(al);//[1, 2, 5, 7, 16]Collections.sort(al,new Comparator() {Overridepublic int compare(Object o1, Object o2) {return (Integer)o2 - (Integer)o1 ;}});System.out.println(al);//[16, 7, 5, 2, 1]}7.4 总结
Comparable 是“比较”的意思而 Comparator 是“比较器”的意思Comparable 是通过重写 compareTo 方法实现排序的而 Comparator 是通过重写 compare 方法实现排序的一个类只有实现了Comparable接口才支持排序,当一个类已经实现Comparable接口但是他的排序方式不满足我的需求时,才使用Comparator接口来满足需求自己写的类优先实现Comparable接口当一个类没有comparab接口是时没办法直接进行排序的,必须去再次实现Comparator接口才可以排序(就算类实现了Comparator接口也无法直接使用Collections.sort() 方法排序)当Comparable和Comparator同时存在时,Comparator优先级高
使用规则:
如果排序逻辑是要排序的对象固有的并且不会更改使用 Comparable。如果需要定义多个排序规则或对未实现 Comparable 的对象进行排序时使用 Comparator。如果一个类实现了 Comparable 接口支持自然排序仍然可以使用 Comparator 进行自定义排序。
八.散列表
8.1 概述
存放单链表的数组(数组里存放的是节点) (Hash table也叫哈希表)是根据键(Key)而直接访问在内存存储位置的数据结构。也就是说它通过计算一个关于键值的函数将所需查询的数据映射到表中一个位置来访问记录这加快了查找速度。这个映射函数称做散列函数存放记录的数组称做散列表。
8.2 底层实现
java中,把散列表封装在HashTable HashMap 和 HashSet中,HashTable已经过时,不推荐使用,被HashMap代替 需要注意 : 使用散列表,需要 同时覆写equals方法和hashCode方法,才能确保数据的唯一性节点中包含4个属性 : key , value , hash , next
添加过程 :
调用key的hashCode方法,生成hash值进行hash算法得到对应的值生成数组下标,判断该位置是否有数据如果没有数据,则创建节点对象,把key和value保存在节点中,并把节点对象 保存在数组中如果有数据,则调用key的equals方法和对应链表中每一个数据进行比较如果相同,则不添加,但是value值覆盖原来的value如果都不相同,说明他们只是下标一样,内容并不一样,所以把该节点对象插入在链表的尾部1.8开始新特性,为了提高查询效率,引入红黑树,因为链表查询效率较低,所以会在添加的时候进行判断如果链表个数大于等于7,把该链表转换为红黑树存储
HashMap默认初始化容量为16,并且默认加载因子是0.75 (16*0.7512 , 也就是说到达12个就开始扩容)
九.map
9.1 HashMap
key不可以重复, value 可以重复
public static void main(String[] args) {
Map map new HashMap();
// 添加
map.put(A, 11);
map.put(A, 12);
map.put(B, 11);
map.put(B, 13);
System.out.println(map);// {A12, B13}
// 查询 根据key值查询 value的值
System.out.println(map.get(A));// 12
System.out.println(map.get(B));// 13// 改 , 和添加一样,已有key为修改,没有的key 为添加
map.put(B, 17);// 删除 根据key删除整个映射关系
map.remove(A);
System.out.println(map);// {B17}// 个数
System.out.println(map.size());// 1// 判断是否包含某个key
System.out.println(map.containsKey(A));// false// 判断是否包含某个value
System.out.println(map.containsValue(17));// true// 清空
map.clear();
System.out.println(map);// {}map.put(A, 13);
map.put(B, 23);// keySet 获取所有的类封装到set中返回
Set set map.keySet();
for (Object object : set) {System.out.print(object : map.get(object) );//A : 13 B : 23
}System.out.println();// values 获取所有value并封装到集合中返回
Collection values map.values();
for (Object object : values) {System.out.print(object );//13 23
}System.out.println();// entrySet 把key和value封装到entry对象中,并保存在set中返回
Set entrys map.entrySet();
for (Object object : entrys) {Entry entry (Entry) object;System.out.print(entry.getKey() : entry.getValue() );//A : 13 B : 23 }
}
9.2 TreeMap
使用treeMap ,key元素类,必须实现Comparable接口并覆写compareTo方法注意treeMap中,排序是按照key进行的和value没有关系
public static void main(String[] args) {TreeMap map new TreeMap();map.put(a,12);map.put(b,11);map.put(x,10);map.put(a1,22);System.outprintln(map);
}十.泛型
10.1 概述
在编译时,进行类型检查 默认集合中是可以保存任意类型元素的(Object),使用泛型后可以使类型统一 因为我们在使用集合的时候,虽然可以保存任意类型元素,但是往往我们只会保存同一种类型由于内部是Object类型,导致所有类型存储的时候都会发生多态,而多态丢失子类特有的属性 因此我们使用的时候,需要向下转型(强制类型转换)如果使用泛型,则不再需要类型转换,使用更方便 泛型只能写引用类型
10.2 使用
public static void main(String[] args) {ListInteger list new ArrayListInteger();list.add(2);list.add(5);list.add(1);//报错,只可以添加int类型的数据//list.add(2);
}TreeMap map new TreeMap();
map.put(a,12);
map.put(b,11);
map.put(x,10);
map.put(a1,22);
System.outprintln(map);} # 十.泛型## 10.1 概述 在编译时,进行类型检查
默认集合中是可以保存任意类型元素的(Object),使用泛型后可以使类型统一
因为我们在使用集合的时候,虽然可以保存任意类型元素,但是往往我们只会保存同一种类型由于内部是Object类型,导致所有类型存储的时候都会发生多态,而多态丢失子类特有的属性
因此我们使用的时候,需要向下转型(强制类型转换)如果使用泛型,则不再需要类型转换,使用更方便
**泛型只能写引用类型**## 10.2 使用java
public static void main(String[] args) {ListInteger list new ArrayListInteger();list.add(2);list.add(5);list.add(1);//报错,只可以添加int类型的数据//list.add(2);
}
