集合
作者：互联网
为什么需要集合
自动扩容，实现无限存放数据（只要服务器够用）
单列（List、set）和多列（map）
ArrayList，LinkedList存数据保证有序
迭代器
集合专有
package jihe;
import java.util.ArrayList;
import java.util.Iterator;
/**
*
**/
public class Demo2 {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
strings.add("111");
strings.add("111");
strings.add("111");
strings.add("111");
strings.add("111");
// for (int i = 0; i < strings.size(); i++) {
// System.out.println(strings.get(i));
//
// }
/**
* 迭代器
*/
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
手写迭代器
package jihe;
import java.util.List;
/**
*
**/
public class MyIterator {
List list;
public MyIterator(List list){
this.list=list;
}
int count=0;
public Object next(){
return list.get(count++);//get后加1
}
public Boolean hasnext(){
if(count < list.size()) {
return true;
}else{
return false;
}
}
}
增强for循环用于数组和集合
package jihe;
import java.util.ArrayList;
/**
*
**/
public class Demo3 {
public static void main(String[] args) {
int[] arrList={1,2,3,4,5,6};
//泛型只用于应用类，基本数据使用其包装类
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5);
for (int i :
arrList) {
System.out.println(i);
}
for (Integer i :
arrayList) {
System.out.println(i);
}
}
}
泛型
jdk1.5没有泛型，ArrayLitsnew类型为Object
泛型用于接口，类，方法
【泛型类】
package jihe;
/**
*泛型类
**/
public class MyFanXin <T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
package jihe;
/**
*
**/
public class Demo4 {
public static void main(String[] args) {
//指定String类型
MyFanXin<String> stringMyFanXin = new MyFanXin<>();
stringMyFanXin.setT("aa");
//指定Integer类型
MyFanXin<Integer> integerMyFanXin = new MyFanXin<>();
integerMyFanXin.setT(11);
}
}
【泛型方法】
package jihe;
/**
*泛型方法
**/
public class Demo5 {
public <T> T show(T t){//返回值不固定可以写一个泛型类最哦为返回对象
return t;
}}
package jihe;
/**
*
**/
public class Demo4 {
public static void main(String[] args) {
Demo5 demo5 = new Demo5();
demo5.show("a");
demo5.show(1);
}
}
【泛型接口】
package jihe;
/**
*
**/
public interface Demo6<T> {
T show(T t);
}
package jihe;
/**
*
**/
public class Demo7<T> implements Demo6<T>{
@Override
public T show(T t) {
return null;
}
}
package jihe;
/**
*
**/
public class Demo8 {
public static void main(String[] args) {
Demo7<String> stringDemo7 = new Demo7<>();
stringDemo7.show("33");
}
}
同时使用泛型接口和泛型方法
package jihe;
/**
*
**/
public interface Demo6<T> {
<M> T show(T t,M m);
}
package jihe;
/**
*
**/
public class Demo7<T> implements Demo6<T>{
@Override
public <M> T show(T t, M m) {
System.out.println(m);
return null;
}
}
package jihe;
/**
*
**/
public class Demo8 {
public static void main(String[] args) {
Demo7<String> stringDemo7 = new Demo7<>();
stringDemo7.show("33",33);//33
}
}
【通配符】
package jihe;
import java.sql.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
*
**/
public class Demo9 {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
show(strings);
}
/**
* List<?>-->可以接受所有的泛型类型，但是不能做添加方法
* @param list
*/
public static void show(List<?> list){
// list.add("a");
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()){
iterator.next();
}
}
}
通配符上限和下限
package jihe;
import java.util.List;
/**
*
**/
public class Demo10 {
public static void main(String[] args) {
}
//上限：接受类型为MyIterator或者其子类
static void show(List<? extends MyIterator>list){
}
//上限：接受类型为MyIterator或者其父类
static void show2(List<? super MyIterator>list){
}
}
可变参数
package jihe;
/**
*可变参数，如果有多个参数，可变参数放在最后
**/
public class Demo11 {
public static void main(String[] args) {
show(1,1,1,1,1);
}
public static void show(int... a){
for (int i :
a) {
System.out.println(i);
}
}
}
可变参数用法
package jihe;
import java.util.Arrays;
import java.util.List;
/**
*
**/
public class Demo11 {
public static void main(String[] args) {
show(1,1,1,1,1);
//Arrays.asList生成的List数量不能发生变化
List<Integer> integers = Arrays.asList(1, 2, 3, 4);
for (Integer i :
integers) {
System.out.println(i);
}
}
public static void show(int... a){
for (int i :
a) {
System.out.println(i);
}
}
}
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
泛型底层擦除机制
package jihe;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
*
**/
public class Demo11 {
public static void main(String[] args) {
List list=new ArrayList();
list.add("My可");
list.add(10);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
public static void show(int... a){
for (int i :
a) {
System.out.println(i);
}
}
}
ArrayList
arraylist按index查找修改效率高
增删效率低
初始化是懒加载：用到是才加载
Linkedlist
双向链表+红黑树
增删效率高，查找效率低O(n)
set
HashSet
- HashSet是set接口的典型实现，大多数时候使用Set集合时就是使用这个实现类
- HashSet按Hash算法来决定集合元素的顺序，具有很好的查找性能
- 当向HashSet集合中存入一个元素时，根据该对象的hashcode值决定该对象在HashSet中的存储位置
hash是什么，是把任意数据通过散列算法变换成固定的输出，该输出就是散列值
package set;
import java.util.HashSet;
import java.util.Set;
/**
*
**/
public class HashSetSample {
public static void main(String[] args) {
/**
* hashset无序不重复
*/
Set<String> strings = new HashSet<>();
strings.add("131311");
strings.add("131312");
strings.add("131331");
strings.add("1311");
strings.add("1311");
strings.add(null);//允许存入null，但只能有一个
System.out.println(strings);//[131331, 1311, 131312, 131311]无序不重复
/**
* get方法属于List，Set无法使用
*/
// strings.get();
}
}
LinkedHahSet
LinkedHahSet是HashSet的子类，除HahSet的特性外，他同时使用链表维护元素的次序，可以保证插入顺序提取数据
TreeSet
底层：红黑树
TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
TreeSet采用红黑树的数据结构来存储集合元素
TreeSet默认采用自然排序对元素升序排列，也可以实现Comparable接口在定义排序方式
Set集合的数据的唯一性
【问题1】
Set集合在新增数据时先判断hashcode是否已经存在
若hashcode存在调用equals进行值比较；
hashcode与equals都存在时，Set才认为数据已存在，不予新增
【问题2】
为甚什么使用hashcode，直接用equals不好吗？
出于效率考虑
hashcode()返回的整数结果决定了set集合中的存放位置，hashcode()计算速度块，但可能出现哈希碰撞
equals()则对值进行比较，处理速度相对较慢
注意：重写hascode和equals根据需要进行判断
掌握HashSet和TreeSet的应用
package set;
import java.util.LinkedHashSet;
/**
*
**/
public class LinkedHashSetSample {
public static void main(String[] args) {
LinkedHashSet<String> strings = new LinkedHashSet<>();
strings.add("1238127789");
strings.add("1233237789");
strings.add("1235341894");
strings.add("4112444149");
System.out.println(strings);//[1238127789, 1233237789, 1235341894, 4112444149]存储时还是遵循hashset，只是访问有序
}
}
package set;
import java.util.Comparator;
import java.util.TreeSet;
/**
*
**/
public class TreeSetSample {
static class IntegerComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;//降序
}
}
public static void main(String[] args) {
TreeSet<Integer> set = new TreeSet<>(new IntegerComparator());
set.add(100);
set.add(140);
set.add(180);
set.add(200);
System.out.println(set);//有序
}
}
Map
key和value可以是任何引用类型，但是key通常是String，key不可重复，反复设置key，后面的value会覆盖前面的
HashMap
对key进行无需存储
不能保证数据按存储顺序读取，且key全局唯一
HashMap与LinkedHashMap的区别
package set;
import java.util.HashMap;
/**
*
**/
public class HashMapSample {
public static void main(String[] args) {
HashMap<String, Object> stringObjectHashMap = new HashMap<String, Object>();
Object put = stringObjectHashMap.put("name", "张三");
Object put1 = stringObjectHashMap.put("name", "张");//如果put是出现重复，会返回原来的值
System.out.println(put1);
}
}
LinkedHashMap按顺序提取数据
TreeMap
存储key-value时，需要根据key对节点进行排序；
TreeMap支持两种Key排序，自然排序和定制排序
底层：红黑树
package set;
import java.util.Comparator;
import java.util.TreeMap;
/**
*
**/
public class TreeMapSample {
static class Resx implements Comparator<String>{
@Override
public int compare(String o1, String o2) {
return o2.compareTo(o1);
}//String:按key排序
}
public static void main(String[] args) {
TreeMap<String, Object> stringObjectTreemAP = new TreeMap<String, Object>(new Resx());
stringObjectTreemAP.put("A1","1");
stringObjectTreemAP.put("C3","2");
stringObjectTreemAP.put("B5","3");
stringObjectTreemAP.put("X1","4");
stringObjectTreemAP.put("B1","6");
System.out.println(stringObjectTreemAP);//自然排序{A1=1, B1=6, B5=3, C3=2, X1=4},使用定制排序：{X1=4, C3=2, B5=3, B1=6, A1=1}
}
}
Map三种遍历方式
for i
foreach
迭代器
package set;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
*
**/
public class LoopSample {
public static void main(String[] args) {
Map<String, Integer> stringIntegerHashMap = new HashMap<>();
stringIntegerHashMap.put("1",1);
stringIntegerHashMap.put("a",2);
stringIntegerHashMap.put("3",3);
stringIntegerHashMap.put("4",4);
stringIntegerHashMap.put("5",5);
stringIntegerHashMap.put("6",6);
/**
* foreach
*/
Set<String> keys= stringIntegerHashMap.keySet();
for (String s:keys
) {
System.out.println(stringIntegerHashMap.get(s));//获取value
}
/**
* lambda表达式
*/
stringIntegerHashMap.forEach((key,value)-> System.out.println(key+value));
/**
*
* 迭代器
*/
Iterator<Map.Entry<String, Integer>> iterator = stringIntegerHashMap.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry<String, Integer> next = iterator.next();
System.out.println(next.getKey());
System.out.println(next.getValue());
}
}
}
通过Conllections实现集合的排序
package set;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
*
**/
public class ListSort {
class SampleCompartor implements Comparator<Integer>{
/**
* o1-o2
* 结果>0,则交换位置
* 结果=0或<0不变
* @param o1
* @param o2
* @return
*/
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
}
public List<Integer> sort(List<Integer> list){
Collections.sort(list,new SampleCompartor());
System.out.println(list);
return list;
}
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(70);
arrayList.add(90);
arrayList.add(30);
arrayList.add(50);
ListSort listSort = new ListSort();
List<Integer> sort = listSort.sort(arrayList);
System.out.println(sort);
System.out.println(arrayList);
}
}
自定义对象比较器
比较器内容-->o1.比较属性（如果属性为String）.compleTo(o2.属性)
标签：java,util,add,static,集合,import,public 来源： https://www.cnblogs.com/yhdxx/p/16557981.html