2024.1.29 Java学习成果展示

 Collection类

方法：add()//向集合中添加元素；isEmpty()//判断集合是否为空；continue()//判断是否包含元素；

           size()//返回集合元素个数；remove()//删除指定元素；      clear() 清空集合

           Object [] toArray ();-将集合转换成数组将数组转换成集合
           Iterator < E > iterator ()-遍历集合中的元素
           Iterator 对象称为迭代器，主要用于遍历 Collection 集合中的元素
           boolean hasnext ()- E next ()﹣返回迭代的下一个元素。
           注意：集合对象每次调用 iterator (）方法都得到一个全新的选代器对象，默认游标都在集               合的第一个元素之前。
           使用 foreach 循环遍历集合元素﹣JDK1.5提供，可以迭代访问 Collection 和数组
           遍历时不需要获取 Collection 或数组的长度，也不需要使用索引访问本质上，底层也是调            用 iterator 
           格式：
           for （要遍历的元素类型遍历后自定义元素名称：要遍历的结构名称）(
           System . ou . printin （遍历后自定义元素名称）;

import java.util.*;

public class CollectionTest {
    public static <object> void main(String[] args) {
        //接口类型的引用指向实现类的对象，形成 多态
        Collection collection = new ArrayList();
        System.out.println(collection);
        //向集合中添加元素，原色的方法为object（所有类型）
        boolean b = collection.add("我上早八");
        System.out.println("b =" + b);
        collection.add(2);
        collection.add('a');
        collection.add(3.14);
        collection.add("我爱上早八");
        System.out.println(collection);
        //判断集合是否为空
        b = collection.isEmpty();
        System.out.println("b = "+ b);
        //判断是否包含指定元素
        b = collection.contains(2);
        System.out.println("b = "+ b);
        //返回包含对象的个数
        int a = collection.size();
        System.out.println("a = "+ a);
        //从集合中删除指定元素
        System.out.println(collection);
        b = collection.remove("我爱上早八");
        System.out.println(collection);
        //将集合转为数组
        Object[] objects = collection.toArray();
        //遍历数组中的元素
        for (int i = 0;i < objects.length; i++){
            System.out.println(objects[i]);
        }
        //将数组转为集合
        List objects1 = Arrays.asList(objects);
        System.out.println(objects1);
        //清空集合
        collection.clear();
        System.out.println(collection);
        System.out.println("=====================");
         //迭代器遍历集合中的元素
        Iterator it = objects1.iterator();
        while (it.hasNext() == true){
            Object obj = it.next();
            System.out.println(obj);
        }
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
        //遍历集合中的元素 3
        for(Object o : objects1){
            System.out.println(o);
        }//for(集合中元素的类型  变量名 ： 集合的引用 )
    }
}

范式

基本概念
通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做 Object 类型放入的，因此从集合中取出元素时也是 Object 类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。为了避免上述错误的发生，从Jdk1.5开始增加泛型机制，也就＜数据类型＞的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。

实例

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Objects;

public class CollectionTest01 {
    public static void main(String[] args) {
        Collection<Object> collection = new ArrayList<>();
        collection.add("AA");
        collection.add("BB");
        collection.add("CC");
        collection.add("DD");
        System.out.println(collection);

    }
}

List类

常用的方法
 void add ( int index , E element ) 向集合中指定位置添加元素

 boolean addAll ( int index , Collection <? extends > c )
 E get ( int index )﹣从集合中获取指定位置元素
 E set ( int index , E element )-修改指定位置的元素
 E remove ( int index )-删除指定位置的元素向集合中添加所有元素
 List < E > subList ( int fromIndex , int toIndex );﹣获取子 List ，前闭后开
注意： subList 获取的 List 与原 List 占有相同的存储空间，对子 List 的操作会影响到原 List 。

实例

package com.java;

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        System.out.println(list);
        list.add(0,"早八");
        list.add(1,13);
        list.add(2,3.14);
        list.add(3,5);
        list.add(4,4.32);
        System.out.println(list);
        System.out.println("===========================");
        //从集合中获取指定位置元素
        Object object1 = list.get(0);
        System.out.println(object1);
        System.out.println(list);
        System.out.println("======================");
        //修改指定位置元素
        object1 = list.set(1, 6);
        System.out.println(list);
        System.out.println("====================");
        //删除指定位置元素
        object1 = list.remove(2);
        System.out.println(list);
        System.out.println("===================");
        //获取子集
        List list2 = list.subList(0,2);
        System.out.println("list集合：" + list);
        System.out.println(list2);
        System.out.println(list);
        System.out.println("====================");
        list2.remove(1);
        System.out.println(list);
        System.out.println(list2);
    }
}

Queue类

常用的方法
 boolean add ( E e )﹣将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true ，如果当前没有可用的空间，则抛出 IllegalStateException .
 E element ()﹣获取，但是不移除此队列的头。
 boolean offer ( E e )-将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add ( E )，后者可能无法插入元素，而只是抛出一个异常。
 E peek ()﹣获取但不移除此队列的头；如果此队列为空，则返回 null 。
 E poll ()﹣获取并移除此队列的头，如果此队列为空，则返回 null 
 E remove ()﹣获取并移除此队列的头。

实例

import java.util.LinkedList;
import java.util.Queue;

public class QueueTest {
    public static  void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        //将数据 11 22 33 44 55 依次入队并打印
        for(int i = 1; i <= 5; i++){
            queue.offer(i * 11);
            System.out.println(queue);
        }
        //查看队首元素并打印
        Integer in = queue.peek();
        System.out.println("队首元素：" +in);

        //将队尾元素打印出来
        int len = queue.size();
        for(int i = 1;i <= len; i++) {
            Integer in1 = queue.poll();
            System.out.println("队尾元素为：" + in1);
        }
    }
}