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) {
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) ) {
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) {
System. out. print ( a + " " ) ;
}
System. out. println ( ) ;
for ( Integer b : ts) {
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 ) ;
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> {
private int id ;
private String name ;
public Employee ( int id, String name) {
this . id = id ;
this . name = name ;
}
@Override
public int compareTo ( Employee obj) {
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) {
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 ( ) ;
System. out. println ( "使用并行流的时间:" + Duration. between ( start, end) ) ;
start = Instant. now ( ) ;
list. stream ( ) . map ( input - > f ( input) ) . forEach ( System. out: : println) ;
end = Instant. now ( ) ;
System. out. println ( "使用顺序流的时间: " + Duration. between ( start, end) ) ;
}
}