Java中泛型与集合

Posted 2021-05-25 nuist__NJUPT

Java中泛型与集合

• 定义一个泛型累Point,包含x,y两个T类型成员，定义两个带参数的构造方法，定义translate()方法将点移到新的坐标

public class Point <T>{
    T x, y ;
    public Point(T x, T y){ //带两个参数的构造方法
        this.x =  x ;
        this.y = y ;
    }
    public T getX(){ //访问方法
        return x ;
    }
    public void setX(T x){ //修改方法
        this.x = x ;
    }
    public T getY(){ //访问方法
        return y ;
    }
    public void setY(T y){ //修改方法
        this.y = y ;
    }
    public void translate(T newX, T newY){ //将点移动到新坐标的方法
        this.x = newX ;
        this.y = newY ;
    }
    @Override
    public String toString(){ //重写字符串方法，返回坐标
        return "(" + this.x + "," + this.y + ")" ;
    }

    public static void main(String[] args){
        Point <Integer> point = new Point<>(3,5) ;
        Point <Double> point1 = new Point<>(3.3, 5.5) ;
        System.out.println(point) ;
        point.setX(1) ;
        point.setY(2) ;
        System.out.println(point) ;
        point.translate(3,4) ;
        System.out.println(point) ;
        System.out.println(point1) ;

    }
}

• 创建一个元素是字符串的ArrayList对象，
• 在其中添加若干元素，用三种方法将每个字符串转换成大写

import java.util.ArrayList;
import java.util.Iterator;
public class UpperCaseDemo {
    public static void main(String[] args){
        ArrayList <String> names = new ArrayList<>() ;
        names.add("Wang") ;
        names.add("Tang") ;
        names.add("li") ;
        names.add("Yao") ;
        for(int i=0; i<names.size(); i++){ //索引循环
            String name1 = names.get(i) ; //得到对应集合下标元素
            name1 = name1.toUpperCase() ; //转换成大写
            names.set(i,name1) ; //设置对应集合元素
            System.out.print(names.get(i) + " ") ; //访问对应集合元素
        }
        for(String name : names){ //增强for循环
            System.out.print(name + " ") ;
        }
        System.out.println() ;

        ArrayList <String> name3 = new ArrayList<>() ;
        name3.add("Chen") ;
        name3.add("Dai") ;
        name3.add("Li") ;
        name3.add("Tao") ;
        Iterator iterator = name3.iterator() ; //使用迭代器的方式输出
        while(iterator.hasNext()){
            String name2 = (String)iterator.next() ;
            name2 = name2.toUpperCase() ;
            iterator.remove() ;
            System.out.print(name2 + " ") ;
        }

        ArrayList <String> name4 = new ArrayList<>() ;
        name4.add("Hu") ;
        name4.add("Ye") ;
        name4.add("Liu") ;
        name4.add("Xue") ;
        name4.replaceAll(String::toUpperCase) ;
       for(String s : name4){
           System.out.print(s + " ") ;
       }
    }
}

• 将一个字符串的单词解析出来，然后将它们添加到HashSet中， 输出每个重复的单词，不同单词的个数，消除重复单词后的列表

import java.util.HashSet;
import java.util.Set;
public class FindDuplicate {
    public static void main(String[] args){
        Set <String> unique = new HashSet<>() ;
        Set <String> duplicate = new HashSet<>() ;
        String message  = "My name name Wang Guo dong" ;
        String [] words = message.split(" ") ; //将字符串按空格划分成数组
        for(String a : words) {
            if (!unique.add(a)){ //如果不在unique集合中，则是重复的元素
                duplicate.add(a) ;
            }
        }
        System.out.println("不同单词的个数" + unique.size()) ;
        System.out.println("不重复的单词" + unique) ;
        unique.removeAll(duplicate) ;
        System.out.println("重复的单词" + duplicate) ;

    }
}

• 随机生成10个两位数，并将其分别存入HashSet和TreeSet
• 然后输出，观察输出结果的不同

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo {
    public static void main(String[] args){
        int [] elements = new int [10] ;
        Set <Integer> hs = new HashSet<>() ;
        Set <Integer> ts = new TreeSet<>() ;
        for(int i=0; i<10; i++){
            elements[i] = (int)(Math.random() * 90 + 10) ;
            hs.add(elements[i]) ;
            ts.add(elements[i]) ;
        }
        for(Integer a : hs){ //HashSet是不重复元素的无顺序输出
            System.out.print(a + " ") ;
        }
        System.out.println() ;
        for(Integer b : ts){ //TreeSet是不重复元素的升序输出
            System.out.print(b + " ") ;
        }
    }

}

• 定义一个对象栈类，要求使用ArrayList类实现该栈

import java.util.ArrayList;
public class MyStack <T>{
    private ArrayList<T> list ;
    public MyStack(){
        list = new ArrayList<T>() ;
    }
    public void push(T obj){ //将元素添加到栈顶
        list.add(0,obj) ;
    }
    public T pop(){ //将元素从栈顶移除
        return list.remove(0) ;
    }
    public T peek(){ //访问栈顶元素
        return list.get(0) ;
    }
    public int getSize(){ //返回栈中元素个数
        return list.size() ;
    }
    public boolean isEmpty(){ //对栈判空操作
        return list.isEmpty() ;
    }
    public int search(T t){
        return list.indexOf(t) ;
    }
    public static void main(String[] args){
        MyStack<Integer> myStack = new MyStack<>() ; //实例化对象
        myStack.push(1) ; //将元素1，2，3入栈
        myStack.push(2) ;
        myStack.push(3) ;
        System.out.println(myStack.search(2)) ; //查找指定元素的位置
        System.out.println(myStack.peek()) ; //访问栈顶元素
        System.out.println(myStack.getSize()) ; //返回栈中元素个数
        myStack.pop() ; //栈顶元素出栈
        myStack.pop() ;
        myStack.pop() ;
        System.out.println(myStack.isEmpty()) ; //判空

    }
}

• 假设Employee类包含一个int型id成员，如果要求Employee可按id值比较大小
• 创建几个Employee对象，并将它放到TreeSet中输出

import java.util.TreeSet;

public class Employee implements Comparable<Employee>{ //实现Comparable接口
    private int id ;
    private String name ;
    public Employee(int id, String name){
        this.id = id ;
        this.name = name ;
    }
    @Override
   public int compareTo(Employee obj) { //重写CompareTo()方法
        return this.id - obj.id;
    }
    public static void main(String[] args){
        Employee [] myList = new Employee[3] ;
        myList[0] = new Employee(2,"王国栋") ;
        myList[1] = new Employee(1,"唐乃乔") ;
        myList[2] = new Employee(3,"陈向军") ;

        TreeSet <Employee> employList = new TreeSet<>() ;
        employList.add(myList[0]) ;
        employList.add(myList[1]) ;
        employList.add(myList[2]) ;
        for(Employee employee : employList){
            System.out.print(employee.id + " " + employee.name) ;
        }
    }

• PriorityQueue是Queue接口的一个实现类，实现一种优先级队列
• 创建一个PriorityQueue对象，将整形数组{1，5，3，7，6，9，8}插入队列
• 观察输出结果

import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueDemo {
    public static void main(String[] args){
        Queue <Integer> queue = new PriorityQueue<>() ;
        int [] value = new int[]{1,5,3,7,6,9,8} ;
        for(int number : value){
            queue.add(number) ;
        }
        while(!queue.isEmpty()){
            System.out.print(queue.remove() + " ")  ;
        }
    }
}

• 编写程序，生成1000个随机生成的三位整数的流，过滤该流
• 使其进包含能被7整除或 含有7的数，输出这些数和个数

import java.util.stream.IntStream;
public class IntStreamDemo {
    public static void main(String[] args){
        int [] value = new int [1000] ;
        for(int i=0; i<value.length; i++){ //生成一个随机的三位整数
            value[i] = (int)(Math.random() * 900 + 100) ;
        }
        IntStream intStream = IntStream.of(value) ; //生成整数流
        //过滤流
        intStream = intStream.filter(number -> (number % 7 == 0 || number % 10 == 7 || number / 10 % 10 == 7 || number / 100 == 7)) ;
        int [] result = intStream.toArray() ; //流中元素存入数组
        for(int elements : result){
            System.out.print(elements + " ") ;
        }
    }
}

• 编写程序，分别使用顺序流和并行流计算10,20,30,40这几个数的阶乘
• 输出结果并计算完成时间，使用并行流是否比使用顺序流快

import java.math.BigInteger;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
public class ParallelStreamDemo {
    public static BigInteger f(long n){ //计算n的阶乘
        BigInteger result = new BigInteger("1") ;
        for(long i=1; i<=n; i++){
           result =  result.multiply(new BigInteger(i + "")) ;
        }
        return result  ;
    }
    public static void main(String[] args){
        Integer [] value = {10,20,30,40} ;
        List <Integer> list = Arrays.asList(value) ; //将数组元转换成集合
        Instant start = Instant.now() ; //开始时间
        list.parallelStream().map(input -> f(input)).forEach(System.out::println);
        Instant end = Instant.now() ; //结束时间以上是关于Java中泛型与集合的主要内容，如果未能解决你的问题，请参考以下文章
 
 学习笔记Java基础知识——泛型与集合
 Java泛型与集合笔记
 Java笔记-泛型与集合框架
 java中泛型的使用
 Java——泛型
 JAVA 泛型与常见的数据结构和集合