黑马程序员——Java集合工具类和泛型

Collections工具类和泛型

Collections和Collection

Collections和Collection是不同的,Collections是工具类,用来操作集合的,而Collection是集合接口。Collections中有一系列的静态方法用来操作集合,但是不能更改集合内容。比如不能set()不能remove()元素,可以替换全部元素或者添加同一个元素。

static List<String> list =Arrays .asList("one Two three Four five six one".split( " "));//Two 和Four有意为之~

public static void main (String[] args) {

// TODO Auto-generated method stub

System.out .println (list) ;

System.out .println ("max="+ Collections. maxlist));

System.out .println ("min="+ Collections. minlist));

System.out .println ("忽略大小写max="+ Collections. max(

list, String. CASE_INSENSITIVE_ORDER));

System.out .println ("忽略大小写min="+ Collections. min(

list, String. CASE_INSENSITIVE_ORDER));

List<String > sublist =Arrays .asList("Four five six" .split (" ")) ;

System.out .println ("indexOfSublist=="+

Collections .indexOfSubList(list , sublist ));

System.out .println ("lastIndexOfSubList=="+

Collections .lastIndexOfSubList (list, sublist)) ;

Collections .replaceAll(list , "one", "YO") ;

System .out.println( "replace"+list );

Collections .reverse(list );

System.out .println ("resever"+ list);

Collections .shuffle(list ,new Random(47 ));

System.out .println ("shuffle"+ ""+list) ;

List<String > source =Arrays .asList("dong ting lake" .split (" ")) ;

Collections .copy(list , source );

System.out .println ("copy"+ ""+list) ;

Collections .fill(list , "pop");

System.out .println ("fill"+ ""+list) ;

System.out .println ("frequency"+

Collections .frequency(list , "pop"));

}

}

/*[one,
Two, three, Four, five, six, one]

max=three

min=Four

忽略大小写max=Two

忽略大小写 min=five

indexOfSublist==3

lastIndexOfSubList==3

replace[YO,
Two, three, Four, five, six, YO]

resever[YO,
six, five, Four, three, Two, YO]

shuffle[three,
five, six, YO, Four, Two, YO]

copy[dong, ting,
lake, YO, Four, Two, YO]

fill[pop,
pop, pop, pop, pop, pop, pop]

frequency7*/

泛型

泛型应用在泛型接口,泛型类和泛型方法中,主要作用是使参数类型化,将运行时参数不匹配错误转移到编译时期,避免强制类型转换。

泛型接口比较好理解,就是说这个接口的实现类有许多的类型,再写这个类的时候,并不知道会有什么类型的类来实现这个接口。

interface Solution< T> {

public void say ();

}

实现这个接口的类可以是泛型的,也可以是具体类型的,比如下面这个类是具体类型的,String。

class GenericTest implements Solution< String> {

public static void main ( String[] args ) {

Solution <String > gt = new GenericTest ();

实现这个接口的类依然是泛型的类。

class GenericTest< T> implements Solution <T >{

public static void main ( String[] args ) {

Solution <String > gt = new GenericTest <String >() ;

Solution <Integer > ss= new GenericTest <Integer >() ;

泛型类和泛型方法

//泛型类

class Solution3< V, T> {

//利用泛型的构造函数

public Solution3( V
name, T other ) {

super ();

this. name = name;

this. other = other;

}

public V
getName() {

return name ;

}

public void setName (V
name ) {

this. name = name;

}

public T
getOther() {

return other ;

}

public void setOther (T
other ) {

this. other = other;

}

V name;

T other;

}

public class GenericC {

public static void main ( String[] args ) {

//由于这个类的构造方法用到了泛型,那么我们可以在泛型范围内

//使用不同的类型来构造对象,没有使用泛型之前你可能无法这么做

//String,String类型的构造函数

Solution3 <String ,String > ss = new Solution3 <String , String >( "方案" , "目标" );

//String,integer类型的构造函数

Solution3 <String ,Integer > si = new Solution3 <String , Integer >( "方案" , 3 );

System .out .println ( "String+Sting"+ ss. getName ()+ ss. other) ;

System .out .println ( "String+Integer"+ si. getName ()+ si. other) ;

/*String+Sting方案目标

String+Integer方案3*/

使用通配符

通配符"?"

class Jiangyou{

}

class Solution5< T> {

T t;

public Solution5( T
t ) {

super ();

this. t = t;

}

}

public class GenericD {

//一个使用了泛型类的对象的方法,将泛型对象定义为通配符“?”

public static void function ( Solution5<?> so ){

System . out. println( "方案:
" +so .t );

}

public static void main ( String[] args ) {

//通配符"?"的权限很大

Solution5 <String > so5 = new Solution5 <String >( "目标" );

//可以是Number基本数据类型

Solution5 <Number > so7 = new Solution5 <Number >( 6 );

//甚至是Object,这里用了个酱油类

Solution5 <Jiangyou > so6 = new Solution5 <Jiangyou >( new Jiangyou()) ;

function( so5 );

function( so6 );

function( so7 );

/*                方案:
目标

方案: [email protected]

方案:
6*/

上限限定

//一个使用了泛型类的对象的方法,将泛型类型上限定为Number的类型

public static void function ( Solution5<? extends Number> so ){

System . out. println( "方案:
" +so .t );

}

public static void main ( String[] args ) {

//Number及其子类都可以调用function方法

Solution5 <Integer > solution = new Solution5 <Integer >( 3 );

Solution5 <Double > solution1 = new Solution5 <Double >( 3. 0 );

//String类型的Solution无法调用function方法

Solution5 <String > solution2= new Solution5< String> ("mubiao" );

function( solution );

function( solution1 );

/*                方案:
3

方案:
3.0*/

下限限定

//一个使用了泛型类的对象的方法,将泛型类型下限定为Integer的类型

public static void function ( Solution5<? super Integer> so ){

System . out. println( "方案:
" +so .t );

}

public static void main ( String[] args ) {

//Integer及其父类都可以调用function方法

Solution5 <Integer > solution = new Solution5 <Integer >( 3 );

//Double不是Integer的父类无法调用function方法

Solution5 <Double > solution1= new Solution5< Double> (3 .0 );

//Object类型的Solution调用function方法

Solution5 <Object > solution2 = new Solution5 <Object >( "mubiao" );

function( solution );

//function(solution1);

function( solution2 );

/*                方案:
3

方案: mubiao*/

黑马程序员——Java集合工具类和泛型,布布扣,bubuko.com

时间: 2024-10-01 05:28:04

黑马程序员——Java集合工具类和泛型的相关文章

黑马程序员——Java基础工具类---Collections、Arrays、超级for循环、静态导入、方法可变参数

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- Collections 一.概述 Collections是对集合框架的一个工具类.它里边的方法都是静态的,不需要创建对象.并未封装特有数据. 在Collections工具类中大部分方法是用于对List集合进行操作的,如比较,二分查找,随机

黑马程序员——Java集合基础知识之Map

Map概念 要同时存储两个元素Key和Value,他们之间有映射关系,每个键不能重复,每个键只能映射到一个值. 当数据之间存在映射关系的时候,考虑使用Map集合. Map常用方法 如果添加的键原来有值,后添加的值会覆盖前面的值,并返回之前的值.put会返回来先添加的值,后添加的值会覆盖原有的值. Map tm =new TreeMap(); tm.put (key, value);//MAP没有add tm.remove (key) ;//去除一个key和对应的value,若不存在key返回nu

黑马程序员——Java集合基础知识之Collection

集合基础知识--Collection Java中集合框架由常用的Collection接口和Map接口组成,而Collection接口又有两个子接口,是List接口和Set接口,常用的集合框架由这三个类组成. List接口的功能方法 List的使用最为简单,创建集合,通过add方法添加元素,get方法获取元素,通过迭代器获取元素.List接口存放的数据无序的,添加速度快,但是查询速度慢,因为查询的时候必须遍历,每次都重头开始,效率较低.常用实现类有ArrayList,LinkedList. Lis

黑马程序员---Java集合框架

---------------------- Android开发.java培训.期待与您交流! ---------------------- Java集合框架 集合我们都知道是用来储存对象的容器,那之前的数组不也可以储存对象么,为什么要出现集合呢? 面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,然而集合类中提供很多方便操作对象存储的方法,要比数组更容易操作对象,而且集合的长度是可变的,然而数组长度确实固定不变的,这样不利于对对象的间隔储存.  数组和集

黑马程序员——java集合框架(Map和工具类)

1.Map体系下有三个子类: HashMap    底层是哈希表数据结构,可以存入null键和null值,不同步---TreeMap    底层是二叉树数据结构,线程同步,可以用于给map集合中的键进行排序 和Set很像,Set底层是Map  添加元素时,如果出现相同键,那么厚添加的值会覆盖原有键对应的值,并且put方法会返回被覆盖的值 2.map集合的两种取出方式:  (1) keySet():将map中所有的键存入到Set集合,因为set具备迭代器                 可以以迭代

黑马程序员——JAVA集合框架学习总结

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- www.itheima.com 要学好java的集合框架,必须掌握此图: Java集合框架很全面,从大的来说.它包括两种类型: 1.一种是以collection为根接口的集合. 2.另一种是由map为根接口的<key,value>的“图”. 而collection之下的set接口和list接口又有不同: 1.Set 接口继承 Collection,但不允许重复,使用自己内部的一个排列机制.

黑马程序员------Java集合框架学习总结

Java培训.Android培训.iOS培训..Net培训.期待您的交流 一.综述 所有集合类都位于java.util包下.集合中只能保存对象(保存对象的引用变量).(数组既可以保存基本类型的数据也可以保存对象). Java的集合类主要由两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口,这两个接口又包含了一些接口或实现类. 二.Collection接口 Collction: List:有序(元素存入集合的顺序和取出的顺序一致),元素都有索引.

黑马程序员——java集合框架之List,Set

集合框架  1.数组与集合的不同    数组长度是固定的,集合长度是可变的    数组中可以存储基本数据类型,集合只存储对象    集合可以存储不同类型的对象        2.java集合类中有两个顶层接口Collection和Map,下面是对Collection的一些总结: 集合中常用方法:     add方法的参数类型为Object,以便于接受任意类型的对象     集合中存储的都是对象的引用(或者说地址) 迭代器是集合取出元素的方式,此方法是定义在集合的内部,这样取出方式就可以直接访问集

黑马程序员------Java中File类学习总结

Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! File类 1.用来将文件或者文件夹封装成对象,以方便对文件和文件夹进行操作. 2.File对象可以作为参数传递给流的构造函数. File对象功能: 创建和删除: 1.boolean createNewFile(): 当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件. 2.boolean mkdir():创建此抽象路径名指定的目录. 3.boolean mkdirs():创建此抽象路径