java 集合类

ArrayList集合的常规操作

• 
  ArrayList长度可变,会随数组元素的增加分配更大的内存,
  

• 
  因此可以把ArrayList看做是一个可变长的数组
  

• 
  由于ArrayList的底层是数组,所以在 增加所删除指定位置元素时会创建新的数组
  

• 
  所以效率会比较低,所以不适合做大量的增删操作
  

package cn.usts.edu.arrayList;
import java.lang.reflect.Array;
import java.util.ArrayList;
/**
* @author ：fly
* @description: ArrayList集合的常规操作
*
ArrayList长度可变,会随数组元素的增加分配更大的内存,
*
因此可以把ArrayList看做是一个可变长的数组
*
由于ArrayList的底层是数组,所以在 增加所删除指定位置元素时会创建新的数组
*
所以效率会比较低,所以不适合做大量的增删操作
*
* @date ：2021/11/1 9:40
*/
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
boolean student1 = al.add("student1");
boolean student2 = al.add("student2");
al.add("student3");
System.out.println(student1);
System.out.println(student2);
System.out.println("集合的长度:"+al.size());
System.out.println("第二个元素是:"+al.get(2));
System.out.println("第最后一个元素是:"+al.get(al.size()-1));
}
}

LinkedList 的基本操作

• ArrayList的查询很快,但是在增删的时候效率就慢了,于是出现了LinkedList
• 链表中每个元素都用引用方式记住前一个和后一个元素,这样在增删的时候效率就会大大提高

package cn.usts.edu.linkedList;
import java.util.LinkedList;
/**
* @author ：fly
* @description: LinkedList 的基本操作
*
ArrayList的查询很快,但是在增删的时候效率就慢了,于是出现了LinkedList
*
链表中每个元素都用引用方式记住前一个和后一个元素,这样在增删的时候效率就会大大提高
*
* @date ：2021/11/1 10:00
*/
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList ll = new LinkedList();
// 添加
ll.add("stu1");
ll.add("stu2");
ll.add("stu3");
ll.add("stu4");
System.out.println(ll);
ll.offer("stu99");// 集合尾部追加
System.out.println(ll);
ll.push("stu00");// 集合头部追加
System.out.println(ll);
// 获取
Object peek = ll.peek();// 获取集合第一个元素
System.out.println(peek);
// 删除
System.out.println("删除了"+ll.removeFirst());// 删除第一个元素
System.out.println(ll);
System.out.println("删除了"+ll.removeLast());// 删除最后一个元素
System.out.println(ll);
System.out.println("删除了"+ll.remove(2));// 删除index=2的元素
System.out.println(ll);
}
}

Iterator的使用方法

• Iterator是java集合框架中的一员,
• 主要用于迭代访问(即遍历)Collection中的元素,
• 因此Iterator对象也被称为迭代器.

package cn.usts.edu.iterator;
import com.sun.deploy.security.BadCertificateDialog;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author ：fly
* @description: Iterator的使用方法
*
Iterator是java集合框架中的一员,
*
主要用于迭代访问(即遍历)Collection中的元素,
*
因此Iterator对象也被称为迭代器.
*
* @date ：2021/11/1 10:16
*/
public class IteratorDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("stu1");
al.add("stu2");
al.add("stu3");
al.add("stu4");
al.add("stu5");
Iterator iterator = al.iterator();// 获取迭代器对象
// hasNext()判断集合中是否存在下一个对象
while (iterator.hasNext()){
System.out.println(iterator.next());// next()取出对象
}
}
}

ForEach(增强for循环)遍历集合

ForEach的出现就是为了解决Iterator写起来太繁琐的问题

package cn.usts.edu.iterator;
import java.util.ArrayList;
/**
* @author ：fly
* @description: ForEach(增强for循环)遍历集合
*
ForEach的出现就是为了解决Iterator写起来太繁琐的问题
* @date ：2021/11/1 10:32
*/
public class ForEachDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("stu1");
al.add("stu2");
al.add("stu3");
al.add("stu4");
al.add("stu5");
for (Object o : al) {
System.out.println(o);// 打印元素
}
}
}

迭代器注意点

package cn.usts.edu.iterator;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author ：fly
* @description: ForEach(增强for循环)遍历集合
*
ForEach的出现就是为了解决Iterator写起来太繁琐的问题
* @date ：2021/11/1 10:32
*/
public class ForEachDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("stu1");
al.add("stu2");
al.add("stu3");
al.add("stu4");
al.add("stu5");
for (Object o : al) {
System.out.println(o);// 打印元素
if (o.equals("stu2")){
al.remove(o);
break;// 如果不加上的话,迭代器会报错,就是把这个元素删除掉了,迭代器下一个元素找不到了,用break跳出循环
/*
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
at java.util.ArrayList$Itr.next(ArrayList.java:861)
at cn.usts.edu.iterator.ForEachDemo.main(ForEachDemo.java:22)
* */
}
}
System.out.println(al);
// 方法二
Iterator iterator = al.iterator();
while (iterator.hasNext()){
if (iterator.next().equals("stu2")){
iterator.remove();
}
}
System.out.println(al);
}
}

JDK8新加的forEach遍历集合

package cn.usts.edu.iterator;
import java.util.ArrayList;
/**
* @author ：fly
* @description: JDK8新加的forEach遍历集合
* @date ：2021/11/1 10:58
*/
public class ForEachJdk8Demo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("stu1");
al.add("stu2");
al.add("stu3");
al.add("stu4");
al.add("stu5");
al.forEach(obj-> System.out.println("迭代集合元素"+obj));
}
}

Iterator实现的遍历结果

@Test
public void iteratorMethod(){
ArrayList al = new ArrayList();
al.add("stu1");
al.add("stu2");
al.add("stu3");
al.add("stu4");
al.add("stu5");
Iterator iterator = al.iterator();
iterator.forEachRemaining(obj-> System.out.println("遍历出来的元素"+obj));
}

HashSet

package cn.usts.edu.hashSet;
import java.util.HashSet;
/**
* @author ：fly
* @description: HashSet的常规操作
* @date ：2021/11/1 17:17
*/
public class HashSetDemo {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add("hello1");
hs.add("hello2");
hs.add("hello3"); // 添加重复元素
hs.add("hello3");
hs.add("hello3");
hs.add("hello4");
hs.forEach(obj-> System.out.println(obj));// 遍历
}
}

HashSet自定义obj类型,存储到haset中去重.

package cn.usts.edu.hashSet;
import org.junit.Test;
import java.util.HashSet;
/**
* @author ：fly
* @description: HashSet的常规操作
*
自己创建的对象要重写hashCode()和equals()方法
*
* @date ：2021/11/1 17:17
*/
public class HashSetDemo {
public static void main(String[] args) {
HashSet hs = new HashSet();
hs.add("hello1");
hs.add("hello2");
hs.add("hello3"); // 添加重复元素
hs.add("hello3");
hs.add("hello3");
hs.add("hello4");
hs.forEach(obj-> System.out.println(obj));// 遍历
}
// 重写hashCode方法,针对自定义存储对象
@Test
public void test02(){
Student stu1 = new Student(1,"Jack");
Student stu2 = new Student(1,"Jack");
HashSet set = new HashSet();
set.add(stu1);
set.add(stu2);
set.forEach(obj-> System.out.println(obj));
//System.out.println(set);
}
}
// pojo
class Student{
private int id;
private String name;
public Student(int id, String name) {
this.id = id;
this.name = name;
}
public Student() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + ''' +
'}';
}
@Override
public int hashCode() {
return name.hashCode();//返回name的hash值
}
@Override
public boolean equals(Object obj) {
if (this == obj){//比较地址值,是否是同一个对象
return true;
}
if (!(obj instanceof Student)){// 不是学生的子类
return false;
}
Student student = (Student) obj;// 是学生的子类,且不是本身
boolean equals = this.name.equals(student.name);// 判断当前类的名字是否和传进来的name一致
return equals;
}
}

TreeSet的使用

package cn.usts.edu.hashSet;
import java.util.TreeSet;
/**
* @author ：fly
* @description: TreeSet常规操作
*
TreeSet的出现解决了HashSet无法排序的问题,
* @date ：2021/11/1 17:50
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(1);
ts.add(82);
ts.add(33);
ts.add(74);
ts.add(5);
ts.add(16);
ts.add(26);
ts.add(36);
ts.add(22);
System.out.println(ts);
System.out.println("第一个是:"+ts.first());
System.out.println("最后一个是:"+ts.last());
System.out.println("集合中小于或等于26的最大的一个元素是:"+ts.floor(26));
System.out.println("集合中大于30的最小的一个元素是:"+ts.floor(30));// 没有返回null
System.out.println("删除第一个"+ts.pollFirst());// 删除第一个
System.out.println("删除最后一个"+ts.pollLast());// 删除最后一个
System.out.println(ts);
}
}

HashMap的常用操作和遍历

遍历:

• 遍历值
  - 增强for / 迭代器
• 遍历value
  - 增强for / 迭代器
• 遍历entrySet
  - 转换MapEntry对象
  - 增强for / 迭代器

package cn.usts.edu.map.hashMap;
import java.util.*;
/**
* @author ：fly
* @description: HashMap 的基本操作
*
hashMap是
Key:Value的形式
*
put()添加
*
get()获取
*
size()大小
*
isEmpty()判空
*
clear()清空
*
remove()删除
*
constainsKey()查找键是否存在
*
*
键不可以重复,key可以为空,value可以重复
*
key相同会覆盖
*
多数情况是String类型的key,value
Object类型都可以
*
*
* @date ：2021/11/2 17:23
*/
//@SuppressWarnings("all")
public class HashMapDemo {
public static void main(String[] args) {
Map map = new HashMap();
map.put("小红","95");
map.put("小名","85");
map.put("小名","85");// 重复不添加
map.put("tom","75");
map.put("lucy",79);
map.put("小军",null);
map.put("小网",null);
map.put(null,null);
map.put(null,"小华");//替换掉上面的null
System.out.println(map);
System.out.println("tom的value="+map.get("tom"));
System.out.println("lucy的value="+map.get("lucy"));
Set keySet = map.keySet();// 获取到所有键的集合
System.out.println(keySet);
System.out.println("小网是否存在:"+map.containsKey("小网"));
System.out.println("小王是否存在:"+map.containsKey("小王"));
System.out.println("是否包含(int)79:"+map.containsValue(79));
System.out.println("是否包含79:"+map.containsValue("79"));
Collection values = map.values();
System.out.println("所有的值="+values);
System.out.println("------------遍历1-------------");
// 方法1通过for循环和get遍历
for (Object key : keySet) {
System.out.println(key + ":" + map.get(key));
}
System.out.println("------------遍历2-------------");
// 方法2 迭代器
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
String item =(String) iterator.next();// 遍历key
System.out.println(item+":"+map.get(item));
}
// 方法3
获取所有values 遍历
System.out.println("------------遍历3-------------");
Collection value = map.values();
for (Object val : value) {
System.out.println(val);
}
// 方法4
通过获取值迭代器遍历
System.out.println("------------遍历4-------------");
Iterator iterValue = value.iterator();
while (iterValue.hasNext()){
System.out.println(iterValue.next());
}
// 方法5 entrySet获取k-v
System.out.println("------------遍历5-------------");
Set entrySet = map.entrySet();
for (Object o : entrySet) {
Map.Entry entry = (Map.Entry) o;
System.out.println(entry.getKey()+ ":" + entry.getValue());
}
// 方法6
entrySet用迭代器 遍历
System.out.println("------------遍历6-------------");
Iterator entryIterator = entrySet.iterator();
while (entryIterator.hasNext()){
Object next = entryIterator.next();
Map.Entry keyValue = (Map.Entry) next;
System.out.println(keyValue.getKey()+":"+keyValue.getValue());
}
}
}

TreeSet排序

Comparator()

package cn.usts.edu.collection.set.treeSet;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @author ：fly
* @description:
TreeSet 可以排序,但是要重写compare方法
* @date ：2021/11/3 15:19
*/
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
System.out.println(((String) o1).compareTo((String) o2));
// compareTo返回比较结果int,然后传入TreeMap中
// TreeMap中的put方法会调用重写compare方法,比较大小,大的放右节点,小的放左节点.
// return ((String) o1).compareTo((String) o2);// 字符串的compareTo方法比较
return ((String) o2).length() - ((String) o1).length();// 长度比较
}
});
treeSet.add("a");
treeSet.add("swallow");
treeSet.add("tree");
treeSet.add("hello");
treeSet.add("hello1");
System.out.println(treeSet);// 直接 输出并不会排序,需要重写compare()
}
}

最后

以上就是和谐小甜瓜为你收集整理的java集合-- 所有HashSet自定义obj类型,存储到haset中去重.TreeSet的使用HashMap的常用操作和遍历的全部内容，希望文章能够帮你解决java集合-- 所有HashSet自定义obj类型,存储到haset中去重.TreeSet的使用HashMap的常用操作和遍历所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。