Queue
队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。先进先出
add()//将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， true在成功后返回 IllegalStateException如果当前没有可用空间，则抛出IllegalStateException。
peek()//检索但不删除此队列的头部，如果此队列为空，则返回 null
poll()//检索并删除此队列的头，如果此队列为空，则返回 null
remove()//检索并删除此队列的头。 此方法与poll不同之处在于，如果此队列为空，它将抛出异常
element()//检索，但不删除，这个队列的头。 此方法与peek的不同之处在于，如果此队列为空，它将抛出异常
Collection
集合框架
Collection接口: 单列集合，用来存储一一个一个的对象
List接口: 存储有序的、可重复的数据。–>“动态”数组
ArrayList（底层以数组存储）、 LinkedList（底层用双链表存储）、 Vector（同ArrayList）
set接口: 存储无序的、不可重复的数据——集合
HashSet（底层以数组存储）、LinkedHashSet、TreeSet
Map接口: 双列集合，用来存储一对(key - value) 的一对的数据 ——相当于函数一个key可以对应多个value
HashMap、LinkedHashMap、TreeMap、 Hashtable、Properties
集合的基本方法:
import java.util.ArrayList;
import java.util.Collection;
public class test {
public static void main(String[] args) {
Collection mylist=new ArrayList();
Collection mylist1=new ArrayList();
mylist.add(909);//添加元素
mylist.add(22.22);
mylist.add(new one("chen"));
mylist.add("sds");
System.out.println(mylist);
Object[] a=mylist.toArray();//把集合转换为数组形式
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
mylist1.add(909);
mylist1.add(22.22);
mylist1.add(new one("chen"));
mylist1.add("sds");
mylist.equals(mylist1);//判断两个集合是否相等
System.out.println(mylist.equals(mylist1));
mylist.contains(909);//判断元素是否在存在于集合内，在返回true
System.out.println(mylist.contains(909));
mylist.containsAll(mylist1);//判断集合是否包含指定集合的所有元素，包含返回true
System.out.println(mylist.containsAll(mylist1));
mylist.isEmpty();//判断集合是否为空，空返回true
System.out.println(mylist.isEmpty());
mylist.remove("sds");//移除集合内指定元素
System.out.println(mylist);
mylist.removeAll(mylist1);//移除和指定集合内相同的元素
System.out.println(mylist);
Collection mylist2=new ArrayList();
}
}
class one{
String a;
public one(String a){
this.a=a;
}
@Override
public String toString() {
return a;
}
}
执行结果：
使用Iterator遍历集合
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTraverse {
public static void main(String[] args) {
Collection mylist = new ArrayList();
mylist.add(32);
mylist.add(0);
mylist.add(90.9);
mylist.add("sdsd");
mylist.add(new IteratorOne("chen"));
/*遍历一般用两个方法：
iterator.next()返回迭代中的下一个元素
iterator.hasNext()如果迭代后还有元素则返回true
*/
Iterator iterator=mylist.iterator();
//方式一：一般的遍历方式，比较少用
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
//方式二：for循环，开发是也不常用
for (int i = 0; i < mylist.size(); i++) {
System.out.println(iterator.next());
}
//方式三一般使用这俩个方法配合起来使用
while(iterator.hasNext()){
System.out.println(iterator.next());
}
// 第一种错误的输出集合内元素:
// Iterator iterator1=mylist.iterator();
// while ((iterator.next())!=null){//这里拿的是第一个元素
// System.out.println(iterator.next());这里输出的是第二个元素,因为第一个已经拿了
// }
// 所以会跳着输出,并且会报异常
// 第二种错误的输出:
// while (mylist.iterator().hasNext()){集合对象每次调用iterator方法都会得到一个全新的对象
// System.out.println(mylist.iterator().next());所以这里会一直输出第一个元素
// }
}
}
class IteratorOne{
String a;
public IteratorOne(String a){
this.a=a;
}
@Override
public String toString() {
return a;
}
}
List接口
List
add(String item)//添加至列表末尾
add(String item,int index)//在指定位置添加
getItem(int index)//获得指定索引关联的项目
remove(int index)//删除指定位置的对象，int是指里面填的是索引位置
remove(String s)//删除第一次出现的对象，可以是其他类型
removeall()//从列表中删除所有项目
ArrayList
是List接口的主要实现类，可以使用Collection的方法
基本方法的使用
下面是ArrayList的部分使用
package List;
import java.util.ArrayList;
public class ArrayListTest {
public static void main(String[] args) {
ArrayList mylist=new ArrayList();
mylist.add("陈");//将指定的元素追加到此列表的末尾
mylist.add("罗");
mylist.add("杨");
mylist.add(1,"张");//在此列表中的指定位置插入指定的元素
System.out.println("mylist链表大小为"+mylist.size());
if(mylist.contains("罗")){//如果此列表包含指定的元素，则返回 true
System.out.println("检测到罗存在");
}
System.out.println("杨的位置为"+mylist.indexOf("杨"));
System.out.println("罗的位置为"+mylist.indexOf("罗"));
System.out.println("陈的位置为"+mylist.indexOf("陈"));
System.out.println(mylist);
if(mylist.isEmpty()){
System.out.println("mylist为空");
}
else {
System.out.println("mylist不为空");
}
mylist.remove("陈");//从列表中删除指定元素的第一个出现（如果存在）。
System.out.println("移除陈之后的大小为"+mylist.size());
mylist.set(1,"刘");//用指定的元素替换此列表中指定位置的元素。
if(mylist.contains("刘")){
System.out.println("检测到刘存在");
System.out.println("位置为"+mylist.indexOf("刘"));
System.out.println(mylist);
}
ArrayList mylist1=new ArrayList();
mylist1.add("范");
mylist1.add("胡");
mylist1.add("卢");
mylist.addAll(mylist1);//按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
System.out.println(mylist);
mylist.remove(0);//删除该列表中指定位置的元素。
System.out.println(mylist);
}
}
输出内容为下：
第一行的代码
import java.util.ArrayList;
这里我不细说，简单的说就是在使用Java API也就是函数库的类的时候，必须指明这个类所在的位置，也就是在Java API的哪个包中，类是被包装在包里面的。这个大部分的编译软件中会告诉你的，你只需要直接使用，会报错提示你添加这行代码，不需要去记忆，也可以通过相关手册直接查阅
代码里面使用的方法在上面都有提到它们的作用，输出大家自己思考一下就知道了
Set接口
存储无序性，不可重复性的数据。
无序性：不等于随机性，存储的数值并非按照数组的索引顺序添加，而是根据数据的hash值决定的。
不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同元素只能添加一个
添加元素的过程：
向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值,此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置)
判断数组此位置上是否已经有元素:
如果此位置上没有其他元素，则元素a添加成功。——>情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素)，则比较元素a与元素b的hash值:
如果hash值不相同，则元素a添加成功。——>情况2
如果hash值相同，进而需要调用元素a所在类的equlas()方法:
equals()返回true,元素a添加失败
equals()返回false,则元素a添加成功。——> 情况3
对于添加成功的情况2和情况3而言:元素a与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素d
public class Main {
public static void main(String[] args) {
// 1. 初始化哈希集合
Set<Integer> hashSet = new HashSet<>();
// 2. 新增键
hashSet.add(3);
hashSet.add(2);
hashSet.add(1);
// 3. 删除键
hashSet.remove(2);
// 4. 查询键是否包含在哈希集合中
if (!hashSet.contains(2)) {
System.out.println("键 2 不在哈希集合中");
}
// 5. 哈希集合的大小
System.out.println("哈希集合的大小为: " + hashSet.size());
// 6. 遍历哈希集合
for (Integer i : hashSet) {
System.out.print(i + " ");
}
System.out.println("在哈希集合中");
// 7. 清空哈希集合
hashSet.clear();
// 8. 查看哈希集合是否为空
if (hashSet.isEmpty()) {
System.out.println("哈希集合为空！");
}
}
}
HsahSet
作为Set 接口的主要实现类;线程不安全的;可以存储null 值
LinkedHashSet
作为HashSet的子类;遍历其内部数据时，可以按照添加的顺序遍历
TreeSet
可以按照添加对象的指定属性，进行排序。
Map
public class Main {
public static void main(String[] args) {
// 1. 初始化哈希表
Map<Integer, Integer> hashmap = new HashMap<>();
// 2. 插入一个新的（键，值）对
hashmap.putIfAbsent(0, 0);
hashmap.putIfAbsent(2, 3);
// 3. 插入一个新的（键，值）对，或者更新值
hashmap.put(1, 1);
hashmap.put(1, 2);
// 4. 获得特定键对应的值
System.out.println("键 1 对应的值为: " + hashmap.get(1));
// 5. 删除键
hashmap.remove(2);
// 6. 检查键是否存在于哈希表中
if (!hashmap.containsKey(2)) {
System.out.println("键 2 不在哈希表中");
}
// 7. 哈希表的大小
System.out.println("哈希表的大小为: " + hashmap.size());
// 8. 遍历哈希表
for (Map.Entry<Integer, Integer> entry : hashmap.entrySet()) {
System.out.print("(" + entry.getKey() + "," + entry.getValue() + ") ");
}
System.out.println("在哈希表中");
// 9. 清空哈希表
hashmap.clear();
// 10. 检查哈希表是否为空
if (hashmap.isEmpty()) {
System.out.println("哈希表为空！");
}
}
}
版权声明：本文为qq_44839044原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。