标签：Java 迭代框架 list System collection println 集合 out

Java集合

一、定义

1、对象的容器，定义了对多个对象进行操作的常用方法，可实现数组的功能
集合所在包为：Java。util.*

2、集合和数组区别：
数组长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能引用类型

二、collection

体系结构

1、Collection父接口

特点：代表一组任意类型的对象，无序、无下标、不能重复
方法：
集合方法

2、collection接口使用

迭代器：
1、iterator():返回按适当顺序在列表上进行迭代的迭代器（参考以上collection接口）
listIterator():按适当顺序，返回此列表元素的列表迭代器
listIterator(int index):按适当顺序返回列表中元素的列表迭代器，从列表的指定位置开始

2、iterator是对collection进行迭代(迭代的意思就是循环或者遍历)的迭代器，有以下几个方法：
hasNext(): void如果仍有元素迭代，则返回true
next():返回迭代的下一个元素
remove():void 从迭代器指向的collection中移除迭代器返回的最后一个元素
迭代过程中只能使用这三个方法，不能使用collection方法，否则会出现并发修改异常

3、listIterator()、listIterator(int index)是列表迭代器，允许按任一方向向前或向后遍历列表、迭代器期间修改列表，并获得迭代器在列表中的当前位置，有以下几个方法：
add():将指定元素插入列表
hasNext():以正向遍历列表，如果列表迭代器有多个元素，则返回true
hasPrevious():如果逆向遍历列表，列表迭代器有多个元素，则返回true
next():返回列表中下一个元素
nextIndex():返回对next的后续调用所返回元素的索引
previous():返回列表中的前一个元素
previousIndex():返回对previous的后续调用所返回元素的索引
remove()
set(E e):用指定元素替换next或previous返回的最后一个元素

添加元素

删除元素

遍历元素

判断元素

获取元素：这是list集合有的操作

collection使用源代码：

package com.an;



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

public class HelloWorld {
public static void main(String[] args) {
    //创建集合
    Collection collection=new ArrayList();
    //添加元素
    collection.add("苹果");
    collection.add("香蕉");
    collection.add("芭乐");
    System.out.println("元素个数为："+collection.size());
    System.out.println(collection);
    //删除元素
    collection.remove("苹果");
    //collection.clear();这是表示删除所有元素
    System.out.println(collection);
    //遍历元素
    System.out.println("使用增强for");
    for (Object object : collection) {
        System.out.println(object);
    }
    System.out.println("使用迭代器");//使用迭代器，迭代器是用来专门遍历集合的一种方法
    Iterator it= collection.iterator();//返回类型是一个接口
    while(it.hasNext()){
        String d=(String) it.next();
        System.out.println(d);
        //collection.remove(d);这里不能用这个方法,否则会出现并发修改异常，但是可以用迭代器里的方法：it.remove()
    }
    //判断
    System.out.println(collection.contains("香蕉"));
}
}

三、List集合

1、List接口

特点：有序、有下标、元素可以重复（有下标就可以用for循环了，像collection接口没有下标就不能用for循环）

方法：
List方法

List接口也是一个有序的collection,也包含了collection里的方法

迭代器：
iterator():返回按适当顺序在列表上进行迭代的迭代器（参考以上collection接口）
listIterator():按适当顺序，返回此列表元素的列表迭代器
listIterator(int index):按适当顺序返回列表中元素的列表迭代器，从列表的指定位置开始

列表迭代器，允许按任一方向遍历列表、迭代器期间修改列表，并获得迭代器在列表中的当前位置

2、List接口使用

list使用源代码

package com.an;



import java.util.*;

public class HelloWorld {
public static void main(String[] args) {
    //创建集合对象
    List list=new ArrayList<>();
    //添加元素
    list.add("苹果");
    list.add("香蕉");
    list.add(0,"芭乐");//从下标为0处插入芭乐
    System.out.println("元素个数为："+list.size());
    System.out.println(list);//或者System.out.println(list.toString（）)
    //删除元素
    list.remove("苹果");
    //collection.clear();这是表示删除所有元素
    System.out.println(list);
    //遍历元素
    //使用for遍历
    System.out.println("使用for循环");
    for(int i=0;i< list.size();i++){
        System.out.println(list.get(i));
    }
    System.out.println("使用增强for");
    for (Object object : list) {
        System.out.println(object);
    }
    System.out.println("使用迭代器");//使用迭代器，迭代器是用来专门遍历集合的一种方法
    Iterator it= list.iterator();//返回类型是一个接口
    while(it.hasNext()){
        String d=(String) it.next();
        System.out.println(d);
        //collection.remove(d);这里不能用这个方法,否则会出现并发修改异常，但是可以用迭代器里的方法：it.remove()
    }
    System.out.println("使用列表迭代器");
    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(list.contains("香蕉"));
    //获取位置
    System.out.println(list.indexOf("香蕉"));
}
}

四、list实现类

ArrayList类：

数组结构实现，查询快，增删慢
有下标，可重复
JDK1.2版本运行效率快、线程不安全

Vector类

数组结构实现，查询快、增删慢
JDK1.0版本运行效率慢，线程安全

LinkedList类

链表结构实现，增删快、查询慢

1、ArrayList的使用

参考文章

2、Vector的使用

vector类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，它的大小可以根据需要增大或者缩小，以适应创建vector后进行添加或溢出项的操作

3、LinkList的使用

存储结构：双向链表

LinkList和ArrayList的区别

ArrayList:必须开辟连续空间，查询快，增删慢
LinkedList:无需开辟连续空间，查询慢，增删快

五、泛型

本质是参数化类型，把类型作为参数传递
常见形式：泛型类、泛型接口、泛型方法
语法：<T,...> T称为类型占位符，表示一种引用类型
好处：提高代码的重用性
防止类型转换异常，提高代码安全性

1、泛型类

语法：类名<T,...>

package com.an;
public class HelloWorld<T> {

    //使用泛型类
    //创建变量
    T t;
//添加方法,使用泛型作为方法参数
public void show(T t){
    System.out.println(t);
}
//泛型作为方法的返回值
public T getT(){
    return t;
}
}







package com.an;
public class TestHelloWorld {
public static void main(String[] args) {
    //使用泛型类创建对象,创建的对象为String类型
    HelloWorld<String> helloWorld= new HelloWorld<String>();
    helloWorld.t="hello";
    helloWorld.show("大家好");
    String string= helloWorld.getT();
}
}

如果在运行是出现遇见javafx.application.Application错误，有可能是运行时选择的启动类不对，选择带有main方法的启动类

2、泛型接口

语法：接口名

接口：

package com.an;
public interface MyInterface<T> {
String name="张三";
T server(T t);//创建一个server方法
}

接口实现类：（要重写接口中的方法）

package com.an;
public class MyInterfaceImp implements MyInterface<String>{
@Override
public String server( String t) {
    System.out.println(t);
    return t;
}
}





package com.an;
public class TestHelloWorld {
public static void main(String[] args) {
    
    MyInterfaceImp imp = new MyInterfaceImp();
    System.out.println("w");

}
}

3、泛型方法

语法：返回值类型

定义泛型方法
package com.an;

public class Method {
public <T> T show(T t){
    System.out.println("泛型方法"+t);
    return t;
}
}



package com.an;



public class TestHelloWorld {
public static void main(String[] args) {
    //泛型方法
    Method method = new Method();
    method.show("大家好");
}


    }

4、泛型集合

参考文章

六、set集合

特点：无序、五下标、元素不可重复
方法：全部继承collection方法

1、set接口使用

package com.an;


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

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    Set<String> set=new HashSet<String>();
    //添加数据
    set.add("苹果");
    set.add("华为");
    set.add("小米");
    System.out.println("数据个数："+set.size());
    System.out.println(set.toString());
    //删除数据
    set.remove("苹果");
    System.out.println(set.toString());
    //遍历数据
    System.out.println("增强for循环");
    for (String string : set) {
        System.out.println(string);
    }
    System.out.println("使用迭代器");
    Iterator<String> it=set.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //判断
    System.out.println(set.contains("华为"));
    System.out.println(set.isEmpty());
}


}

七、set实现类

1、HashSet：

基于HashCode计算元素存放位置
当存入元素的哈希码相同时，会调用equals进行确认，如结果为true，则拒绝后者存入
存储结构：哈希表（数组+链表+红黑树）(参考下数据结构里的散列函数)

package com.an;


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

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    HashSet<String> hashSet=new HashSet<String>();
    //添加数据
    hashSet.add("苹果");
    hashSet.add("华为");
    hashSet.add("小米");
    System.out.println("数据个数："+hashSet.size());
    System.out.println(hashSet.toString());
    //删除数据
    hashSet.remove("苹果");
    System.out.println(hashSet.toString());
    //遍历数据
    System.out.println("增强for循环");
    for (String string : hashSet) {
        System.out.println(string);
    }
    System.out.println("使用迭代器");
    Iterator<String> it=hashSet.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //判断
    System.out.println(hashSet.contains("华为"));
    System.out.println(hashSet.isEmpty());
}


}

2、HashSet存储方式

第一步：根据HashCode计算存储的位置，如果位置为空，则直接保存，如果不为空执行第二步
第二步：再执行equals方法，如果equals方法为true，则认为是重复，否则形成链表

八、TreeSet(红黑树)

基于排列顺序实现元素不重复
实现了SortedSet接口，对集合元素自动排序
元素对象的类型必须实现Comparable接口，指定排序规则
同过compareTo方法确定是否为重复元素

1、TreeSet使用

存储结构：红黑树
使用treeset保存数据，要求元素必须实现Comparable接口，否则会出现ClassCastException异常
CompareTo方法

treeset使用

treeset使用2

2、Comparator接口使用

comparator迭代器
有迭代器就不需要用25行后面的代码了

九、Map集合

Map

Map父接口：

1、Map使用

Map1
Map2
Map3

2、HashMap使用

线程不安全，运行效率快，允许用null作为key或者value
存储结构：哈希表（数组+链表+红黑树）
使用key计算出来的HashCode和equals一样可作为重复
HashMap

key不可以重复，如果重复的化，会覆盖原来的值，value可以重复
HashMap1

3、Hashtable

线程安全，运行效率慢，不允许null作为key或者value
properties是是Hashtable的子类，要求keyhe1value都是string,通常用于配置文件的读取

4、treeMap

实现了SortedMap接口（是Map的子接口），可以对key自动排序
存储结构：红黑树
treeMap

treeMap0
treeMap1
treeMap2

十、collection工具类

collection工具类

package com.an;


import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) {
    //创建集合
    List<Integer> list = new ArrayList<>();
    //添加数据
    list.add(1);
    list.add(3);
    list.add(2);
    System.out.println("数据个数：" + list.size());
    System.out.println(list.toString());
    //排序
    Collections.sort(list);
    System.out.println(list.toString());
    //binarysearch二分法检索
    int i = Collections.binarySearch(list, 3);
    System.out.println(i);
    //copy复制
    List<Integer> dest = new ArrayList<>();
    for (int k = 0; k < list.size(); k++) {
        dest.add(0);
    }
    Collections.copy(dest, list);
    System.out.println(dest.toString());
    //reverse反转
    Collections.reverse(list);
    System.out.println(list);
    //shuffle打乱
    Collections.shuffle(list);
    System.out.println(list);
    //list转成数组
    Integer[] arr = list.toArray(list.toArray(new Integer[0]));
    System.out.println(Arrays.toString(arr));
    //数组转成集合,这里的集合是一个受限集合，不能添加和删除
    String[] name = {"一", "二", "三"};
    List<String> list1 = Arrays.asList(name);
    System.out.println(list1);
    //把基本类型数组转为集合时，需要修改为包装类型
    Integer[] num = {1, 2, 3, 4};
    List<Integer> s = Arrays.asList(num);
    System.out.println(s);
    }


}

十、总结

集合总结

标签：Java,迭代,框架,list,System,collection,println,集合,out
From： https://www.cnblogs.com/ChenAiNan/p/16608351.html

Java集合框架