java08

"冬止"

已于 2024-09-06 17:29:19 修改

阅读量588

点赞数 5

分类专栏： java学习文章标签：开发语言 java 职场和发展

于 2024-09-06 09:01:14 首次发布

本文链接：https://blog.csdn.net/zyq2217330101/article/details/141949909

版权

java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、java HashSet

HashSet基于HAshMap来实现的，是不允许有重复元素的集合
HashSet允许有空值
HashSet是无序的，就是不会记录插入顺序
HashSet不是线程安全，如果有多个线程尝试同时修改HashSet，则最终结构是不确定的，必须在多线程访问时，显式同步对Hash的兵法访问
HashSet实现了set接口

        //HashSet

        //创建一个HashSet对象
        HashSet<String>hashset01=new HashSet<String>();
        //向集合中添加元素
        hashset01.add("hello");
        hashset01.add("hello02");
        hashset01.add("hello03");//是无序的
        hashset01.add("hello");//重复的元素不会被添加
        System.out.println(hashset01);
        //判断元素是否存在
        System.out.println(hashset01.contains("hello"));//存在输出true
        System.out.println(hashset01.contains("你好"));//不存在输出false
        //删除集合中的元素
        hashset01.remove("hello");
        System.out.println(hashset01);
        //删除所有元素
        hashset01.clear();
        System.out.println(hashset01);
        //重新添加
        hashset01.add("hello");
        hashset01.add("hello02");
        //计算元素大小
        System.out.println(hashset01.size());
        //迭代输出hashset中的元素
        //普通的for循环不行，因为是无序的
       /*
        for(int i=0;i<hashset01.size();i++)

        {
            System.out.println(hashset01);
        }
         */
        //for增强
        for(String x:hashset01)
        {
            System.out.println(x);

        }

二、java HashMap

HashMap是一个散列表，它存储的内容是键值对映射
HashMap实现了Map接口，根据键的HashCode的值存储数据，具有很快的访问速度，最多允许一条记录的键为NULL，不支持线程同步
HashMAp是无序的，即不会记录插入的顺序
HashMap的key和value类型可以相同也可以不同，

        //HashMap
        //创建一个HashMap的对象
        HashMap<Integer,String>hashmap01=new HashMap<Integer, String>();
        //向HashMap中添加元素，使用put方法
        hashmap01.put(1,"hello000");
        hashmap01.put(2,"hello0001");
        hashmap01.put(3,"hello0002");
        hashmap01.put(4,"hello02");
        //获取元素，使用get（key）
        System.out.println(hashmap01.get(1));
        //输出全部集合
        System.out.println(hashmap01);
        //删除元素 使用remove（key）
        hashmap01.remove(4);
        System.out.println(hashmap01);
        //删除集合内的所有元素使用clear
        hashmap01.clear();
        System.out.println(hashmap01);
        //重新添加元素
        hashmap01.put(1,"hello000");
        hashmap01.put(2,"hello0001");
        hashmap01.put(3,"hello0002");
        hashmap01.put(4,"hello02");
        //计算大小，使用size()
        System.out.println(hashmap01.size());
        //迭代HashMap
        //想要获取key值使用keyset();通过key获取values
        for(int x:hashmap01.keySet())
        {
            System.out.println(x);
            System.out.println(hashmap01.get(x));
        }
        //直接获取values的值
        for(String x:hashmap01.values())
        {
            System.out.println(x);

        }

三、java Iterator 迭代器

是java集合中的一种机制，是一种用于遍历集合的接口
它提供了统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节
java迭代器不是一个集合，是一种用来访问集合的方法
Iterator是java迭代器中最贱单的实现
迭代器接口定义了机种方法，一下是最常用的三种
next():返回迭代器的下一个元素，并将迭代器的指针移到下一个位置
hasNext（）：用于判断集合中是否还有下一个元素可以访问
remove（）：从集合中删除迭代器最后访问的元素（可选操作）
通过使用迭代器，我们可以逐个访问集合中的元素而不是通过传统的for循环或者索引，这种方式更加简洁灵活，并且适用于各种类型的集合

        //获取迭代器
        Iterator<String> it=arraylist01.iterator();
        //获取集合第一个元素
        System.out.println(it.next());
        //获取集合中的全部元素
        while(it.hasNext())
        {
            System.out.println(it.next());
        }

        //创建一个链表
        LinkedList<Integer>linkedlist01=new LinkedList<Integer>();
        //添加元素
        linkedlist01.add(1);
        linkedlist01.add(2);
        linkedlist01.add(3);
        linkedlist01.add(4);
        linkedlist01.add(5);
        //创建一个迭代器
        Iterator<Integer>it02=linkedlist01.iterator();
        //删除元素通过remove（）
        while(it02.hasNext())
        {
         if((it02.next())<3)
         {
             it02.remove();//删除元素
         }
        }
        System.out.println(linkedlist01);

四、java object 类

java object是所有类的父类，也就是说java的所有类都继承了object，子类可以使用object的所有方法
在创建一个类时，如果没有明确的继承一个父类，那么它就会自动继承object，成为object的子类
显式继承：

public class Runoob extends Object{

}

隐式继承：

public class Runoob {

}

五、java泛型

泛型的本质是参数化类型，也就是说操作的数据类型被指定成为一个参数

（一）泛化方法

class test01{
    public static <E> void printArray(E[]inputArray)
    {
        //输出数组元素
        for(E x:inputArray)
        {
            System.out.println(x);
        }
    }
    public static void main(String[]args)
    {
        Integer[]intArray={1,2,3,4,5};
        Double[]doubleArray={1.1,2.2};
        Character[]chars={'1','2'};
        printArray(intArray);
        printArray(doubleArray);
        printArray(chars);

    }
}

（二）泛化类

class Box<T>
{
    private T t;
    public void add(T a)
    {
        this.t=a;
    }
    public T get()
    {
        return t;
    }
    public static void main(String[]args)
    {
        Box<String>stringBox=new Box<String>();
        Box<Integer>integerBox=new Box<Integer>();

        stringBox.add("字符串");
        integerBox.add(2);
        System.out.println(stringBox.get());
        System.out.println(integerBox.get());
    }
}

（三）类型通用符

类型通用符一般使用？代替具体的类型方式，例如List<?>在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。

class test02{
    public static void main(String[]args)
    {
        //定义不同类型的动态数组
        List<String>name=new ArrayList<String>();
        List<Integer>id=new ArrayList<Integer>();
        name.add("小红");
        id.add(18);

        getDate(name);
        getDate(id);
       // getUperNumber(name);//1
        getUperNumber(id);//2


    }
    public static void getDate(List<?>date)//name id都可以作为这个方法的实参
    {
        System.out.println(date.get(0));
    }
     public static void getUperNumber(List<? extends Number> data) {//只能接收number以及其下层子类类型
         System.out.println("data :" + data.get(0));
     }
 }

"冬止"

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
java08

HashMap实现了Map接口，根据键的HashCode的值存储数据，具有很快的访问速度，最多允许一条记录的键为NULL，不支持线程同步。通过使用迭代器，我们可以逐个访问集合中的元素而不是通过传统的for循环或者索引，这种方式更加简洁灵活，并且适用于各种类型的集合。java object是所有类的父类，也就是说java的所有类都继承了object，子类可以使用object的所有方法。它提供了统一的方式来访问集合中的元素，而不需要了解底层集合的具体实现细节。HashMAp是无序的，即不会记录插入的顺序。
复制链接

扫一扫