java常用工具集合

其他 2019-11-21 09:34:12 阅读次数: 0

1、集合和数组的区别： 

①集合中只能存储引用型数据，如果存储基本类型会自动装箱；数组既可以存储基本类型也可以存储引用类型的数据。

②集合长度不固定，可任意扩充；数组长度固定。

2、Java的集合体系：

（1）单列集合：（顶层是Collection接口）

①List集合（list是接口，要想使用里面的方法必须创建子类对象） ：最常用的子类是ArrayList

List集合中元素可重复，有序。通过创建子类对象使用：List list=new ArrayList();

eg:向List集合中添加三个元素并遍历打印

分析：向集合中添加元素的方法：add()、遍历集合的方式：for()、获取集合中元素个数的方法：size()

package com.wang.list;

import java.util.ArrayList;
import java.util.List;
/*List是接口，要创建子类对象
使用集合的步骤：创建集合对象-》创建元素对象-》将元素对象添加到集合对象中-》遍历集合
 */
public class ListDemo01 { public static void main(String[] args) { //往List集合中添加3个学生对象，然后遍历 //创建集合对象 List list=new ArrayList(); //创建元素对象 Student s1=new Student("王迎婧",22); Student s2=new Student("王迎",21); Student s3=new Student("王",20); Student s4=new Student("王",20); //将元素添加到集合对象中 //add方法返回是否添加成功的布尔值  list.add(s1); list.add(s2); list.add(s3); list.add(s4); //直接打印集合,怎样添加的就怎样打印，并且可重复 System.out.println(list); //获取索引为2的元素 System.out.println(list.get(2)); Object obj=list.get(2); System.out.println(obj); //获取集合的长度 int a=list.size(); System.out.println(a); //遍历集合 for(int i=0;i<list.size();i++){ System.out.println("索引为"+i+"的元素是："+list.get(i)); } //增强for循环 for(Object x:list){//集合中添加的元素都是Object类型 System.out.println(x); } } } class Student{ private String name; private int age; public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public Student(){}; public Student(String name,int age){ this.name=name; this.age=age; } @Override public String toString() { return "Student{name='"+getName()+"',age="+getAge()+"}"; }}

增强for循环和迭代器

 

增强for循环的格式：for(数据类型 变量名：数组或集合对象){//循环体，变量即元素}
 

 

iter回车：增强for循环的快捷方式
 

 

        for(Object x:list){//集合中添加的元素都是Object类型
            System.out.println(x);
       }
 

 

增强for循环的底层依据的是迭代器（Iterator）：增强for就是迭代器的简写形式
 

 

迭代器： 对过程的重复，称为迭代。迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添            加、删除等操作
 

 

迭代器的常用方法： next():返回迭代的下一个元素对象
 

 

                                   hasnext():判断迭代器中是否有下一个元素，如果仍有元素可以迭代，则返回true
 

 

迭代器的使用步骤： 通过集合对象获取其对应的迭代器对象->判断迭代器中是否有元素->如果有，获取元素
 

 

普通的迭代器在遍历集合的同时不能添加或删除元素，否则会报：并发修改异常
 

 

列表迭代器在遍历集合的同时可以修改集合中的元素，必须使用列表迭代器中的方法
 

 

eg：通过迭代器遍历List集合
 

 

package com.wang.list;
 

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
 

 

//通过迭代器遍历List集合
public class ListDemo02 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //根据集合对象获取其对应的迭代器对象
        Iterator i=list.iterator();
        //迭代器中是否有元素
 

 

        while (i.hasNext()){//如果有元素就一直迭代
            //如果有就获取这个元素
            Object o=i.next();
            //数据类型都是字符串，可以向下转型
            String s=(String)o;
            System.out.println(s);
        }
        System.out.println("==========================================");
        //判断集合中如果有字符串"b",有就在后面添加一个新的字符串"java"
        //添加、删除操作需要列表迭代器
        ListIterator lis=list.listIterator();
        while(lis.hasNext()){
            String s=(String)lis.next();
            if("b".equals(s)){//常量与变量比较时，常量写到前面，变量写在括号中。
                            //常量调用方法，即使常量是null也能规避控指针异常
                //能走到这里说明集合中有字符串"b"
                lis.add("java");
            }
            System.out.println(s);
        }
        System.out.println(list);
    }
}
 

泛型
 

什么是泛型：泛指任意类型，又叫参数化类型（ParameterizedType），对具体类型的使用起到辅助作用，类似于方法的参数。
 

泛型一般只与集合类结合使用。
 

集合类泛型：如果在集合对象上写了一个泛型，就表示该集合中存放指定类型的元素。
 

例如：在list集合上加上泛型String：List <String> list=new ArrayList<>();说明在这个集合中只能添加字符串类型的数据。
 

package com.wang.list;
​
import java.util.ArrayList;
import java.util.List;
​
//演示泛型
public class ListDemo03 {
    public static void main(String[] args) {
      //不使用泛型的集合
      List list1=new ArrayList();
      list1.add("a");//添加数据为Object类型
      list1.add("b");
      list1.add("c");
      list1.add("d");
     // list1.add(10);//可以添加整数型，但在遍历时不能向下转型，会报类型转换异常
        for (Object o : list1) {
            String s=(String)o;
            System.out.println(s);
       }
        System.out.println("==============================");
      //泛型，避免类型转换的问题
        List <String> list2=new ArrayList<>();
        list2.add("d");//泛型是什么类型，就只能添加什么类型的数据
        list2.add("e");
        list2.add("f");
        for (String s : list2) {
            System.out.println(s);
       }
   }
}
​
 

collection工具类
 

针对及集合进行操作的工具类。
 

成员方法： sort(List<T>): 根据元素的自然顺序（0-9、a-z），将指定列表按升序排序
 

                    max(Collection<T>):返回集合中的最大元素
 

                    reverse(List<T>):反转集合中的元素
 

                    shuffle(List<T>):使用默认的随机源随机置换指定的列表
 

package com.wang.collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
​
/*sort(List<T>): 根据元素的自然顺序（0-9、a-z），将指定列表按升序排序
  max(Collection<T>):返回集合中的最大元素
  reverse(List<T>):反转集合中的元素
  shuffle(List<T>):使用默认的随机源随机置换指定的列表
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        List <Integer>list=new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(2);
        list.add(4);
        System.out.println("没有操作前，集合中的数据是"+list);
        System.out.println("==============================");
        //获取集合中最大元素,max是Collection中的静态方法，可通过类名直接调用
        Integer max= Collections.max(list);
        System.out.println("集合中的最大元素为："+max);
       /* //对集合中的数据进行反转
        Collections.reverse(list);
        System.out.println("反转后集合中数据为："+list);
        //对集合进行升序排列
        Collections.sort(list);
        System.out.println("排序后的集合数据为："+list);
        //对集合中的数据降序排序,先升序排列，再反转
        Collections.reverse(list);
        System.out.println("集合中元素降序排序："+list);
​
        */
        //随机置换，相当于洗牌
        Collections.shuffle(list);
        System.out.println("随机置换后的结果为："+list);
        Collections.shuffle(list);
        System.out.println("随机置换后的结果为："+list);
​
 }
}
 

②Set ：
 

特点：不可重复、无序
 

Set接口要创建子类对象使用，最常用子类：HashSet
 

eg：向Set集合中添加五个元素，并遍历打印
 

package com.wang.set;
​
import javax.swing.text.html.HTMLDocument;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
​
public class SetDemo01 {
    public static void main(String[] args) {
        //向Set集合中添加5个元素，并遍历打印
        Set <Student> set=new HashSet<>();
        Student s1=new Student("wang",22);
        Student s2=new Student("wangy",21);
        Student s3=new Student("wangyi",20);
        Student s4=new Student("wangyin",19);
        Student s5=new Student("wang",22);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        /*为什么打印结果没有去重？
        因为Set集合保证元素的唯一性依赖：equals()和HashCode()，两个方法。现在没有在学生类中重写这两个方法，
        所以默认调用的是Object类中的这两个方法，而Object类中的equals方法默认比较的是地址值是否相同
​
        解决方法：在Student中重写equals和HashCode方法
         */
     
        //通过迭代器遍历Set集合
        //1、通过集合对象获取其对应的迭代器对象
        Iterator<Student> it=set.iterator();
        //2、判断迭代器中是否有元素
        while (it.hasNext()){
            //3、如果有，就获取元素
           Student s= it.next();
            System.out.println(s);
       }
        System.out.println("===========================");
        for (Student student : set) {
            System.out.println(student);
       }
   }
}
class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
   }
​
    public void setName(String name) {
        this.name = name;
   }
​
    public String getName() {
        return name;
   }
​
    public void setAge(int age) {
        this.age = age;
   }
​
    public int getAge() {
        return age;
   }
​
    @Override
    public String toString() {
        return "Student{name='"+getName()+"',age="+getAge()+"}";
   }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
   }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
   }
}
 

双列集合 ：（顶层是Map接口：key、value）
 

Map ：Map接口最常用子类：HashMap
 

特点：双列集合，元素由键值对（Entry）构成
 

键用key表示，值用value表示   key不可以重复，value可以重复
 

Map<T1,T2> map=new HashMap<>();
 

T1表示键的类型，T2表示值的类型
 

eg：向Map集合中添加三个元素，并遍历打印  
 

向Map集合中添加元素的方法为：put()
 

遍历集合的方式：获取所有的key：keySet(),遍历keySet，通过key获取value：get()
 

步骤：1、创建集合对象 Map <Integer,Student> map=new HashMap<>()；
 

           2、分别创建三个Student对象
 

           3、使用put方法将Student对象添加到集合中
 

           4、获取所有的key，并使用迭代器迭代
 

package com.wang.map;
​
import java.util.*;
​
public class MapDemo01 {
    public static void main(String[] args) {
        Map<Integer,Student> map=new HashMap<>();
        Student s1=new Student("wang",22);
        Student s2=new Student("wangy",21);
        Student s3=new Student("wang",22);
        /*添加元素，元素第一次添加，返回null，重复添加，会用新值覆盖旧值，并返回旧值
        Student stu1=map.put(1,s1);
        System.out.println(stu1);
        Student stu2=map.put(1,s2);
        System.out.println(stu2);
         */
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);
        System.out.println(map);
        //根据键，获取值
        Student stu3=map.get(2);
        System.out.println("key:"+2+",value:"+stu3);
        System.out.println("===============================");
        //遍历集合,双列集合不能直接遍历，要先转化为单列集合
        //1、获取所有键的集合：keySet()
        Set<Integer> keys=map.keySet();
        //2、遍历所有的键，获取到每一个键
        //迭代器
        Iterator<Integer> it=keys.iterator();
        while (it.hasNext()){
            Integer key=it.next();
        //3、根据键，获取指定的值 get()
        Student value=map.get(key);
            System.out.println("key:"+key+",value:"+value);
       }
        System.out.println("=================================");
        //增强for
        for (Integer key : keys) {
            Student value=map.get(key);
            System.out.println("key:"+key+",value:"+value);
       }
   }
}
class Student{
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.age=age;
   }
​
    public void setName(String name) {
        this.name = name;
   }
​
    public String getName() {
        return name;
   }
​
    public void setAge(int age) {
        this.age = age;
   }
​
    public int getAge() {
        return age;
   }
​
    @Override
    public String toString() {
        return "Student{name='"+getName()+"',age="+getAge()+"}";
   }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
   }
​
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
   }
}
 

 

                    
                    
                    
                    
                    
                    
                    
                    
                    

                        
猜你喜欢

                        

                            
                            
                        

                    


                    
转载自www.cnblogs.com/wyj96/p/11903535.html

                    

                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                    

                    


                

            

            


                

                    

                        
                        
                        
                        
                    


                    

                        

                            

                                今日推荐
                            


                            

                        

                    

                    

                        

                            

                                TIOBE 5 月榜单：Fortran “复活”进入 Top 10
                            

                        

                        

                            

                                GCC 14.1 发布
                            

                        

                        

                            

                                面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
                            

                        

                        

                            

                                开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
                            

                        

                        

                            

                                中国码农的“35岁魔咒”
                            

                        

                        

                            

                                蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
                            

                        

                        

                            

                                Arc Browser for Windows 1.0 正式 GA
                            

                        

                        

                            

                                90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
                            

                        

                        
                        
                    

                


                

                    

                        

                            

                                周排行
                            

                            

                        

                    

                    

                        

                            

                                Java自定义时间格式
                            

                        

                        

                            

                                同步整形电路
                            

                        

                        

                            

                                在开发中最最最常用的字符串的属性大集合
                            

                        

                        

                            

                                Linux 查看端口占用并杀掉
                            

                        

                        

                            

                                Java基础四：ArrayList
                            

                        

                        

                            

                                多线程之死锁就是这么简单
                            

                        

                        

                            

                                mysql 基础命令集
                            

                        

                        

                            

                                awk 命令详解
                            

                        

                        

                            

                                Centos6.3编译安装nginx+php步骤
                            

                        

                        

                            

                                OCR （Optical Character Recognition，光学字符识别）
                            

                        

                    

                

                

                    

                        

                            

                                每日归档
                            

                            

                                更多
                            

                            

                        

                    

                    

                        

                            2024-05-08(42)
                        

                        

                            2024-05-07(14)
                        

                        

                            2024-05-06(40)
                        

                        

                            2024-05-05(0)
                        

                        

                            2024-05-04(7)
                        

                        

                            2024-05-03(19)
                        

                        

                            2024-05-02(0)
                        

                        

                            2024-05-01(4)
                        

                        

                            2024-04-30(1)
                        

                        

                            2024-04-29(40)
                        

                    

                


            


            
        

    






















    


        

            
代码天地 © 2018 codetd.com

            境外服务器
             
            最新电视剧2022