如题:假如有个set集合,其中有10个元素,怎么能取出其中的4个元素!!!

Set<String> s = new TreeSet<String>();

for (int i = 0; i < 10; i++) {

sadd(i + "");

}

Iterator<String> i = siterator();

int sum = 0;

while (ihasNext()) {

if (sum <= 3) {

Systemoutprintln(inext());

}

sum += 1;

}

Map和Set的 *** 作：增、删、判断、取出。

add和put的不同：

Set是单列集合，添加相同的元素，所以add方法只添加一个进去。Map的put方法如果添加了多个键相同的元素，则会用最后添加的值来覆盖之前的值，而这个键是最先添加的那个，并每天有被覆盖这一说。

凡是遇到hash，hashmap或者hashset，底层数据结构都是哈西表，存储数据的时候一样，都是先判断当前哈西值和已添加元素的哈希值是否相同，如果不相同，就存数据，不然就继续判断equals方法，若返回true就不存，返回false就存。所以元素都要复写一下hashCode（）和equals（）方法。

注意：判断元素是否存在以及删除 *** 作，依赖于这两个方法，这就是哈希表的特性。（ArrayList只依赖equals方法）

而遇到Tree开头的，TreeSet 和TreeMap，底层都是二叉树，存储数据遵循小的在左大的在右的原则，每个数下面最多只能有两个分支，新添加进去的数据依次往下比。若存的多了，会自动折中查找，所以这种数据结构的效率是比较高的。

Tree类型的查重：

比较器，对于不具有自然顺序的类型，比如一个Student类

（1）让这个类具备可比性

让Student类实现Comparable这个接口，然后重写里面的compareTo()方法， 返回值为0是保证唯一性的依据 ：

（2）让将要添加这个类的对象的集合比如Set，具有可比性

自定义一个比较器MyCompare，实现Comparato这个接口，并把newMyCompare()当作参数传进Set这个类当中。

重写Comparator里面的compare()方法，这个方法里面有两个参数O1和O2，比较这两个对象的toString()值。比如下面：

public int compare(Object o1, Object o2) {

Book b1 = (Book)o1;

Book b2 = (Book)o2;

return b1getDate()toString() compareTo (b2getDate()toString());

}

两种比较器，重写的方法都是int类型。所以Tree类型存储数据只看相比的结果：正、负、0。0决定存不存，保证唯一性，正负决定存储的顺序。

注意： 在定义student这个类的时候，最好把hashCode()和equals()都重写一下（还有toString()，然后让这个类实现comparable接口或者自定一个比较器。这样一来，student既可以存进hashset里面又可以存进TreeSet里面。

TreeSet的方法：

E ceiling(E e) 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。

first() 返回此 set 中当前第一个（最低）元素

floor(E e) 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。

HashMap：

里面存的是键值对，一个键可以对应多个值，但一个值只可以对应一个键。那么hashmap可不可以存空键后面跟一个值？能！

直接返回值。

Map 集合没有迭代器，它的取出方式有两种：

第一种是KeySet()方法，把键存进Set集合中，然后用Set集合的迭代器遍历得到所有的键，再用Map集合的get()方法，参数传入键，取出值。

第二种是entrySet()方法，把键值对这种映射关系存进Set集合。调用entry()，返回值实际上包含了键和值两个数据，用getke'y（）方法和        getvalue（）两个方法，可以分别取出键和值。

TreeMap sets = new TreeMap(new MyCompare());

Set set = setsentrySet();

Iterator it = setiterator();

while (ithasNext()) {

/加了泛型的话，直接返回string key和string value，

然后用key和value调用getKey()和getValue()方法，不然。就用下面的强转/

Entry entry = (Entry)itnext();

Systemoutprintln(entrygetKey()+entrygetValue());

前言

本文目录

Scala字符串 Scala 集合 1 数组 2 list 3 set 4 Map 42 map遍历 方式一: foreach 方式二: 迭代器 方式三: for循环 5 元组 trait特性 模式匹配match-case 并发 Actor Model Actor的特征： Actor与Actor之间通信: Scala隐式转换系统 隐式值 隐式视图 隐式类

Scala字符串

Scala中字符串也是分为两种: 可变长度的StringBuilder和不可变长度的String, 其 *** 作用法与Java几乎一致

接下来, 通过代码来查看常用方法：

//定义字符串 val str1 = "Hello Scala" var str2 = "Hello Scala" var str2_1 = "hello scala" //字符串比较 println(str1 == str2) println(str1equals(str2)) println(str1equalsIgnoreCase(str2_1)) //上述三个比较全部返回true //按字典顺序比较两个字符串 println(str1compareTo(str3)) //按字典顺序比较两个字符串，不考虑大小写 println(str1compareToIgnoreCase(str3)) //从0开始返回指定位置的字符 println(str1charAt(6)) //追加 println(str2concat(" Language")) //是否以指定的后缀结束 println(str1endsWith("la")) //使用默认字符集将String编码为 byte 序列 println(str1getBytes) //哈希码 println(str1hashCode) //指定子字符串在此字符串中第一次出现处的索引 println(str1indexOf("ca")) //字符串对象的规范化表示形式 println(str1intern()) //指定子字符串在此字符串中最后一次出现处的索引 println(str1lastIndexOf("al")) //长度 println(str1length) //匹配正则表达式 println(str1matches("d+")) //替换字符 println(str1replace('a','o')) //根据字符切割, 需要注意Scala中从数组中取元素使用小括号 println(str1split(" ")(1)) //是否以指定字符串开始 println(str1startsWith("Hel")) //截取子字符串 println(str1substring(3)) println(str1substring(3,7)) //大小写 println(str1toLowerCase()) println(str1toUpperCase()) //去空格 println(str1trim) //使用StringBuilder val strBuilder = new StringBuilder //拼接字符串 strBuilderappend("Hello ") strBuilderappend("Scala") println(strBuilder) //反转 println(strBuilderreverse) //返回容量 println(strBuildercapacity) //指定位置插入 println(strBuilderinsert(6,"Spark "))

Scala 集合

1 数组

Java中使用 new String[10]的形式可以创建数组, 但Scala中创建数组需要用到Array关键词, 用[ ]指定数组中元素的泛型, 取值使用小括号(index)

//创建Int类型的数组, 默认值为0 val nums = new Array[Int](10) //创建String类型的数组, 默认值为null val strs = new Array[String](10) //创建Boolean类型的数组, 默认值为false val bools = new Array[Boolean](10) //通过索引遍历数组,给元素赋值 for (index <- 0 until numslength) nums(index) = index + 1 //数组遍历,编码的逐步简化 numsforeach ( (x: Int) => print(x + " ") ) println() numsforeach ( (x => print(x + " ")) ) println() numsforeach(print(_)) println() numsforeach(print)

foreach函数传入一个函数参数, 由于Scala支持类型推测, 可以将参数函数的参数类型省略; 在参数函数中, 该函数的参数只出现一次, 因为可以使用下划线_代替(如果有多个可以使用_1/_2); 最后由于Scala语言的灵活性, 只需传入print这个函数也会遍历打印整个集合

创建二维数组分两步: 创建一个泛型为数组的数组, 然后对这个数组遍历,

val secArray = new Array[Array[String]](5) for (index <- 0 until secArraylength){ secArray(index) = new Array[String](5) } //填充数据 for (i <- 0 until secArraylength;j <- 0 until secArray(i)length) { secArray(i)(j) = i j + "" } secArrayforeach(array => arrayforeach(println))

2 list

Scala中列表的定义使用List关键词 List集合是一个不可变的集合 下面来看创建List已经list调用的方法

//创建列表 val list = List(1,2,3,4,5) //对列表遍历 listforeach(println) //contains判断是否包含某个元素 println(listcontains(6)) //反序,返回一个新的List listreverseforeach(println) //去前n个元素,返回一个新的List listtake(3)foreach(println) //删除前n个元素,返回一个新的List listdrop(2)foreach(println) //判断集合中是否有元素满足判断条件 println(listexists(_ > 4)) //把List中的元素用设置的字符(串)进行拼接 listmkString("==")foreach(print) /map是一个高阶函数,需要一个函数参数 返回值是That,意思是谁调用的map返回的类型跟调用map方法的对象的类型一致 这里map返回的仍然是list,因此在map中可对每一个元素进行相同 *** 作 map返回的list的泛型由编码传入的函数返回类型决定,如下(_ 100)返回的list的泛型就是Int / listmap(println) listmap(_ 100)foreach(println) val logList = List("Hello Scala" , "Hello Spark") /由上述介绍可知,split()返回一个数组,因此map返回的类型是泛型为数组类型的list 需要对返回的list进行两次遍历,第一次遍历得到Array,第二次遍历拿到String / logListmap(_split(" "))foreach(_foreach(println)) / 如果想直接拿到String,需要: 扁平 *** 作 用到的函数是flatMap,flatMap返回的类型也是调用该方法的类型,但它可以直接得到String类型的单词 / logListflatMap(_split(" "))foreach(println) 对map和flatMap的理解可参考下图: Nil创建一个空List Nilforeach(println) //:: *** 作可用来添加元素 val list1 = 1::2::Nil list1foreach(println) 需要注意的是, 上述创建的list均为不可变长度的list, 即list中的元素只有在创建时才能添加 创建可变长度的list, 需要用到ListBuffer, 看代码: //创建一个ListBuffer,需要导包scalacollectionmutableListBuffer val listBuffer = new ListBuffer[String] //使用+=添加元素 listBuffer+=("hello") listBuffer+=("Scala") listBufferforeach(println) //使用-=去除元素 listBuffer-=("hello")

3 set

Scala中使用Set关键词定义无重复项的集合

Set常用方法展示:

//创建Set集合,Scala中会自动去除重复的元素 val set1 = Set(1,1,1,2,2,3) //遍历Set即可使用foreach也可使用for循环 set1foreach(x => print( x + "\t")) val set2 = Set(1,2,3,5,7) //求两个集合的交集 set1intersect(set2)foreach(println) set1&(set2)foreach(println) //求差集 set2diff(set1)foreach(println) set2&~(set1)foreach(println) //求子集,如果set1中包含set2,则返回true注意是set1包含set2返回true println(set2subsetOf(set1)) //求最大值 println(set1max) //求最小值 println(set1min) //转成List类型 set1toListmap(println) //转成字符串类型 set1mkString("-")foreach(print)

4 Map

Scala中使用Map关键字创建KV键值对格式的数据类型

41 创建map集合

val map = Map( "1" -> "Hello", 2 -> "Scala", 3 -> "Spark" )

创建Map时, 使用->来分隔key和value, KV类型可不相同, 中间使用逗号进行分隔

42 map遍历

遍历map有三种方式, 即可使用foreach, 也可使用与Java中相同用法的迭代器, 还可使用for循环

方式一: foreach

mapforeach(println)

此时, 打印的是一个个二元组类型的数据, 关于元组我们后文中会详细介绍, 此处只展示一下二元组的样子: (1,Hello); (2,Scala); (3,Spark)

方式二: 迭代器

val keyIterator = mapkeysiterator while (keyIteratorhasNext){ val key = keyIteratornext() println(key + "--" + mapget(key)get) }

此时需注意:

mapget(key)返回值, 返回提示:

an option value containing the value associated with key in this map, or None if none exists

即返回的是一个Option类型的对象, 如果能够获取到值, 则返回的是一个Some(Option的子类)类型的数据, 例如打印会输出Some(Hello), 再通过get方法就可以获取到其值;

如果没有值会返回一个None(Option的子类)类型的数据, 该类型不能使用get方法获取值(本来就无值, 强行取值当然要出异常)

看get方法的提示(如下), 元素必须存在, 否则抛出NoSuchElementException的异常

Returns the option's value Note: The option must be nonEmpty

Throws:

PredefNoSuchElementException - if the option is empty

既然这样, 对于None类型的数据就不能使用get了, 而是使用getOrElse(“default”)方法, 该方法会先去map集合中查找数据, 如果找不到会返回参数中设置的默认值 例如,

//在上述map定义的情况下执行下述代码,会在终端打印default

println(mapget(4)getOrElse("default"))

1

2

方式三: for循环

for(k <- map) println(k_1 + "--" + k_2)

此处, 将map中的每一对KV以二元组(1, Hello)的形式赋给k这一循环变量 可通过k_1来获取第一个位置的值, k_2获取第二个位置的值

43 Map合并

//合并map val map1 = Map( (1,"a"), (2,"b"), (3,"c") ) val map2 = Map( (1,"aa"), (2,"bb"), (2,90), (4,22), (4,"dd") )

map1++:(map2)foreach(println)

++和++:的区别

函数 调用 含义

++ map1++(map2) map1中加入map2

++: map1++:(map2) map2中加入map1

注意：map在合并时会将相同key的value替换

44 Map其他常见方法

//filter过滤,虑去不符合条件的记录 mapfilter(x => { IntegerparseInt(x_1 + "") >= 2 })foreach(println) //count对符合条件的记录计数 val count = mapcount(x => { IntegerparseInt(x_1 + "") >= 2 }) println(count); / 对于filter和count中条件设置使用IntegerparseInt(x_1 + "")是因为: 定义map时,第一个key使用的是String类型,但在传入函数时每一个KV转化为一个二元组(Any,String)类型,x_1获取Any类型的值,+""将Any转化为String,最后再获取Int值进行判断 / //contains判断是否包含某个key println(mapcontains(2)) //exist判断是否包含符合条件的记录 println(mapexists(x =>{ x_2equals("Scala") }))

5 元组

元组是Scala中很特殊的一种集合, 可以创建二元组, 三元组, 四元组等等, 所有元组都是由一对小括号包裹, 元素之间使用逗号分隔

元组与List的区别: list创建时如果指定好泛型, 那么list中的元素必须是这个泛型的元素; 元组创建后, 可以包含任意类型的元素

创建元组即可使用关键字Tuple, 也可直接用小括号创建, 可以加 “new” 关键字, 也可不加 取值时使用 "tuple_XX"获取元组中的值

元组的创建和使用

//创建元组 val tuple = new Tuple1(1) val tuple2 = Tuple2("zhangsan",2) val tuple3 = Tuple3(1,20,true) val tuple4 = (1,2,3,4) val tuple18 = (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18) //注意:使用Tuple关键字最多支持22个元素 val tuple22 = Tuple22(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22) //使用 println(tuple2_1 + "\t" + tuple2_2) //元组中嵌套元组 val t = Tuple2((1,2),("zhangsan","lisi")) println(t_1_2) 元组的遍历 //tupleproductIterator可以得到迭代器, 然后用来遍历 val tupleIterator = tuple22productIterator while(tupleIteratorhasNext){ println(tupleIteratornext()) } toString, swap方法 //toString, 将元组中的所有元素拼接成一个字符串 println(tuple3toString()) //swap翻转，只对二元组有效 println(tuple2swap)

trait特性

Scala中的trait特性相对于Java而言就是接口 虽然从功能上两者极其相似, 但trait比接口还要强大许多: trait中可以定义属性和方法的实现, 这点又有点像抽象类; Scala的类可以支持继承多个trait, 从结果来看即实现多继承

Scala中定义trait特性与类相似, 不同在于需要使用"trait"关键字 其他注意点在代码注释中做出说明:

trait Read { val readType = "Read" val gender = "m" //实现trait中方法 def read(name:String){ println(name+" is reading") } } trait Listen { val listenType = "Listen" val gender = "m" //实现trait中方法 def listen(name:String){ println(name + " is listenning") } } //继承trait使用extends关键字,多个trait之间使用with连接 class Person extends Read with Listen{ //继承多个trait时,如果有同名方法或属性，必须使用“override”重新定义 override val gender = "f" } object test { def main(args: Array[String]): Unit = { val person = new Person() personread("zhangsan") personlisten("lisi") println(personlistenType) println(personreadType) println(persongender) } } object Lesson_Trait2 { def main(args: Array[String]): Unit = { val p1 = new Point(1,2) val p2 = new Point(1,3) println(p1isEqule(p2)) println(p1isNotEqule(p2)) } } trait Equle{ //不实现trait中方法 def isEqule(x:Any) :Boolean //实现trait中方法 def isNotEqule(x : Any) = { !isEqule(x) } } class Point(x:Int, y:Int) extends Equle { val xx = x val yy = y def isEqule(p:Any) = { / isInstanceOf:判断是否为指定类型 asInstanceOf:转换为指定类型 / pisInstanceOf[Point] && pasInstanceOf[Point]xx==xx } }

模式匹配match-case

Scala中的模式匹配match-case就相当于Java中的switch-case Scala 提供强大的模式匹配机制, 即可匹配值又可匹配类型 一个模式匹配包含一系列备选项, 每个备选项都以case关键字开始 并且每个备选项都包含了一个模式以及一到多个表达式, 箭头符号 => 隔开了模式和表达式。

object Lesson_Match { def main(args: Array[String]): Unit = { val tuple = Tuple7(1,2,3f,4,"abc",55d,true) val tupleIterator = tupleproductIterator while(tupleIteratorhasNext){ matchTest(tupleIteratornext()) } } / 注意 1模式匹配不仅可以匹配值,还可以匹配类型 2模式匹配中,如果匹配到对应的类型或值，就不再继续往下匹配 3模式匹配中,都匹配不上时，会匹配到case _ ,相当于default / def matchTest(x:Any) ={ x match { //匹配值 case 1 => println("result is 1") case 2 => println("result is 2") case 3 => println("result is 3") //匹配类型 case x:Int => println("type is Int") case x:String => println("type is String") case x :Double => println("type is Double") case _ => println("no match") } } }

由于匹配到对应的类型或值时, 就不再继续往下匹配, 所有在编写备选项时要将范围小的放在前面, 否则就会失去意义 这就类似于try-catch中处理异常时, 也要先从小范围开始

样例类case classes

使用case关键字定义的类就是样例类(case classes), 样例类实现类构造参数的getter方法 (构造参数默认被声明为val) , 当构造参数类型声明为var时, 样例类会实现参数的setter和getter方法

样例类默认实现toString, equals, copy和hashCode等方法 样例类在创建对象时可new, 也可不new

//使用case关键字定义样例类 case class Person(name:String, age:Int) object Lesson_CaseClass { def main(args: Array[String]): Unit = { //创建样例类对象,可new可不new val p1 = new Person("zhangsan",18) val p2 = Person("lisi",20) val p3 = Person("wangwu",22) val list = List(p1,p2,p3) listforeach { x => { x match { case Person("zhangsan",18) => println("zhs") case Person("lisi",20) => println("lisi") case p:Person => println("is a person") case _ => println("no match") } } } } }

并发 Actor Model

Actor Model相当于Java中的Thread, Actor Model用来编写并行计算或分布式系统的高层次抽象 Actor不需要担心多线程模式下共享锁的问题, 可用性极高

Actors将状态和行为封装在一个轻量级的进程/线程中, 但它不和其他Actors分享状态, 每个Actors有自己的世界观, 当需要和其他Actors交互时, 通过发送异步的, 非堵塞的(fire-and-forget)事件和消息来交互 发送消息后不必等另外Actors回复, 也不必暂停, 每个Actors有自己的消息队列, 进来的消息按先来后到排列, 这就有很好的并发策略和可伸缩性, 可以建立性能良好的事件驱动系统

Actor的特征：

ActorModel是消息传递模型,基本特征就是消息传递

消息发送是异步的，非阻塞的

消息一旦发送成功，不能修改 (类似发邮件)

Actor之间传递时，自己决定决定去检查消息，而不是一直等待，是异步非阻塞的

定义Actor需要继承Actor这一trait, 实现act这一方法, 并且使用感叹号! 来发送消息

一个简单实例:

import scalaactorsActor //自定义Actor class myActor extends Actor{ def act(){ while(true){ receive { case x:String => println("save String ="+ x) case x:Int => println("save Int") case _ => println("save default") } } } } object Lesson_Actor { def main(args: Array[String]): Unit = { //创建actor的消息接收和传递 val actor =new myActor() //启动 actorstart() //发送消息写法 actor ! "Hello Scala Actor !" } }

Actor与Actor之间通信:

//创建样例类,用来发送 case class Message(actor:Actor,msg:Any) class Actor1 extends Actor{ def act(){ while(true){ //对接收的消息进行模式匹配 receive{ case msg :Message => { println("i sava msg! = "+ msgmsg) //回复消息 msgactor!"i love you too !" } case msg :String => println(msg) case _ => println("default msg!") } } } } //为了实现Actor中的通信,需要拿到另一个Actor的对象 class Actor2(actor :Actor) extends Actor{ //发送消息 actor ! Message(this,"i love you !") def act(){ while(true){ receive{ case msg :String => { if(msgequals("i love you too !")){ println(msg) actor! "could we have a date !" } } case _ => println("default msg!") } } } } object Lesson_Actor2 { def main(args: Array[String]): Unit = { val actor1 = new Actor1() actor1start() val actor2 = new Actor2(actor1) actor2start() } }

Scala隐式转换系统

隐式转换是指在编写程序时, 尽量少的去编写代码, 让编译器去尝试在编译期间自动推导出某些信息来, 这就类似于在Scala中定义变量时不需要指定变量类型 这种特性可以极大的减少代码量, 提高代码质量

Scala中提供强大的隐式转换系统, 分别为: 隐式值, 隐式视图和隐式类

隐式值

先来看一个隐式值的Demo:

object Lesson_Implicit1 { def main(args: Array[String]): Unit = { implicit val name = "Scala Study" sayName } def sayName(implicit name:String) = { println("say love to " + name) } }

这里将name变量声明为implicit, 编译器在执行sayName方法时发现缺少一个String类型的参数, 此时会搜索作用域内类型为String的隐式值, 并将搜索到的隐式值作为sayName的参数值进行传递

需要注意:

隐式转换必须满足无歧义规则, 否则会报错:

ambiguous implicit values: both value a of type String and value name of type String match expected type String

在同一个作用域禁止声明两个类型一致的变量，防止在搜索的时候会犹豫不决

声明隐式参数的类型最好是自定义的数据类型，一般不要使用Int,String这些常用类型，防止碰巧冲突

隐式视图

隐式视图就是把一种类型自动转换为另一种类型 还是先来看代码:

object Lesson_Implicit2 { def main(args: Array[String]): Unit = { //声明隐式视图 implicit def stringToInt(num:String) = IntegerparseInt(num) println(addNum("1000")) } def addNum(num:Int) = { num + 1000 } }

这里addNum方法参数是String类型, 不符合定义要求, 此时编译器搜索作用域发现有个隐式方法, 正好这个方法的参数是String, 返回是Int 然后就会调用这个隐式方法, 返回一个Int值并将它传给addNum方法

隐式类

隐式类是指把一个对象自动转换为另一种类型的对象, 转换后可以调用原来不存在的方法

package comqbscala object Lesson_Implicit3 { def main(args: Array[String]): Unit = { //导入隐式类所在的包 import comqbscalaUtilStringLength println("qwer"getLength()) } } object Util { //定义一个隐式类,使用implicit关键字修饰 implicit class StringLength(val s : String){ def getLength() = slength } }

这里编译器在qwer对象调用getLength方法时, 发现该对象并没有getLength方法, 此时编译器发现在作用域范围内有隐式实体 发现有符合的隐式类可以用来转换成带有getLength方法的Util类, 进而就可调用getLength方法

需要注意:

隐式类所带的构造参数有且只能有一个

必须在类, 伴生对象和包对象中定义隐式类

隐式类不能是case class(样例类), case class 在定义时会自动生成伴生对象

作用域中不能有与隐式类同名的标识符

感谢大家支持，之后会持续输出技术干货！

看了好所有的答案都不靠谱，我也遇到你的问题了。自己研究了一下，el表达式可以 *** 作部分对象的方法，可以用来解决这个问题。

el表达式

${obj[index]}

这种形式只能读取数组、List对象。不能读取Collection，因此可以使用Collection的toArray()方法后取第一个。注：Set对象是Collection子集，详见JDK源码。

${collectiontoArray()[0]}

说明：先从整体介绍了Java集合框架包含的接口和类，然后北京IT培训总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。

1、综述

所有集合类都位于javautil包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。

当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK15以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。

Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。

Set、List和Map可以看做集合的三大类。

List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。

Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。

Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。

对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayList和HashMap三个实现类。（并发控制的集合类，以后有空研究下）。

2、Collection接口

Collection接口是List、Set和Queue接口的父接口，同时可以 *** 作这三个接口。

Collection接口定义 *** 作集合元素的具体方法大家可以参考API文档，这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。

3、两种遍历集合的方法Iterator接口和foreach循环  1、Iterator接口

Iterator也是Java集合框架的成员，主要用于遍历（即迭代访问）Collection集合中的元素，也称为迭代器。

通过remove和add方法，set集合中的对象属性为private final

Set接口

集合里的多个对象没有明显顺序。Set集合和Collection基本一样，没有

提供额外方法，只是和Collection行为不同

Set集合不允许包含相同的元素，如果add的是两个相同元素会返回false

Set不实用==运算符，根据equals方法

HashSet类

HashSet类是Set接口的典型实现，大多数时候使用Set集合都是用这个类实现

HashSet按Hash算法来存储集合中的元素

HashSet特点：

1不能保证元素的排列顺序，顺序可能变化

2HashSet不是同步的，多个线程同时访问一个Set集合，必须用代码

保证同步

3集合元素值可以是null

当向HashSet集合中存入一个元素，HashSet会调用该对象的HashCode（）

得到对象的hashCode，根据HashCode来决定对象在HashSet中的位置

如果两个元素equal方法比较返回true但是hashCode()方法返回值不同，

HashSet会把两个元素存储在不同位置

HashSet判断两个元素相同需要equal和hashCode都相同

因此重写类的equals方法和hashCode()方法要保证两个对象通过equals

返回true时hashCode也相等

Hash算法保证通过一个对象快速找到另一个对象。可以很快的执行，当需要

查找集合中的某个元素时，hash算法可以直接根据该元素的值找到该元素

从而让程序快速找到元素。

在数组中通过数组元素索引寻找元素，HashSet通过hashcode索引

重写hashCode()方法的基本步骤

当两个对象通过equals方法返回true时，两个对象的hashCode相等

对象中用作equals比较标准的属性，应该用来计算hashCode

向HashSet中添加可变对象时，如果修改HashSet集合中对象，有可能导致

该对象与集合中其他对象相等，从而导致HashSet无法正确访问对象

HashSet有一个子类 LinkedHashSet,LinkedHashSet集合也是根据HashCode来决定

元素的存储位置，同时使用链表维护元素次序，这样是的元素看起来是以

插入顺序保存，便利集合时会按插入顺序来访问。

Linked需要维护元素的插入顺序，性能略低于HashSet,但在迭代时性能更好

TreeSet是SortedSet接口的唯一实现

TreeSet可以确保元素处于排序状态。提供了几个额外方法：

1Comparator

comparator():返回当前Set使用的Comparator,或者null,表示

自然的方式排序

2Object first():返回集合中的第一个元素

3Object last():返回集合中最后一个元素

4Object lower(Object

e):返回集合中位于指定元素之前的元素

5Object higher(Object

e):返回集合中位于制定元素之后的元素

6SortedSet

subSet(fromElement,toElement):返回set的子集，范围从from到to

7SortedSet headSet(toElement)返回set子集，小于toElement

8SortedSet

tailSet(fromElement)返回set子集，由大于等于fromElement元素组成

TreeSet是根据元素值来进行排序而不是根据插入顺序

TreeSet采用红黑树的数据结构对元素排序 ：支持自然排序（默认）和定制排序

自然排序：

TreeSet会调用集合元素的compareTo方法来比较元素之间的大小关系，

然后将集合元素按升序排列。

Java提供了一个Comparable接口，该接口定义了一个compareTo(Object obj)方法

该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象

可以比较大小。obj1compareTo(obj2)，如果方法返回0，表明两个对象相等。如果

返回正整数，表明obj1大于obj2;如果返回负整数，表明obj1小于obj2

如果要将对象添加如TreeSet该对象必须实现Comparable接口

当想TreeSet中添加对象时，会先将要添加的对象与TreeSet中的对象用compareTo比较

如果找不到compareTo则引发ClassCastException异常

因为只有同一个类型才能比较大小 所以TreeSet中添加的应该是同一个类型的对象

TreeSet和HashSet集合中的对象如果是可变对象，对象属性改变时，会导致集合处理

对象复杂化，易出错。所以应该尽量在集合中添加不可变对象

不可变对象是

1属性为private final

2含有带参数构造器，为对象初始化

3属性有get方法没有set方法

定制排序：

TreeSet的自然排序是根据集合元素大小，TreeSet将它们以升序排列。使用定制

排序，如降序，使用Comparator接口的帮助。接口中包含一个int compare(T o1,T o2)

用于比较o1和o2的大小：重写该方法可以改变排序规则

以上就是关于如题:假如有个set集合,其中有10个元素,怎么能取出其中的4个元素!!!全部的内容，包括:如题:假如有个set集合,其中有10个元素,怎么能取出其中的4个元素!!!、Set、Map集合的区别、如何证明，在n个元素组成的集合中取n+1个不同的三元子集，求证必有两个子集，它们恰有一个公共元等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！