Ⅰ java中的Set,List,Map的区别
对JAVA的集合的理解是想对于数组
数组是大小固定的 并且同一个数组只能存放类型一样的数据(基本类型/引用类型)
JAVA集合可以存储和操作数目不固定的一组数据
所有的JAVA集合都位于 java util包中!
JAVA集合只能存放引用类型的的数据 不能存放基本数据类型
JAVA集合主要分为三种类型
Set(集)
List(列表)
Map(映射)
Collection 接口
Collection是最基本的集合接口 声明了适用于JAVA集合(只包括Set和List)的通用方法
Set 和List 都继承了Conllection Map没有
Collection接口的方法
boolean add(Object o) :向集合中加入一个对象的引用
void clear() :删除集合中所有的对象 即不再持有这些对象的引用
boolean isEmpty() :判断集合是否为空
boolean contains(Object o): 判断集合中是否持有特定对象的引用
Iterartor iterator() : 返回一个Iterator对象 可以用来遍历集合中的元素
boolean remove(Object o):从集合中删除一个对象的引用
int size() :返回集合中元素的数目
Object[] toArray() :返回一个数组 该数组中包括集合中的所有元素
关于 Iterator() 和toArray() 方法都用于集合的所有的元素 前者返回一个Iterator对象 后者返回一个
包含集合中所有元素的数组
Iterator接口声明了如下方法
hasNext(): 判断集合中元素是否遍历完毕 如果没有 就返回true
next() :返回下一个元素
remove():从集合中删除上一个有next()方法返回的元素
Set(集合)
Set是最简单的一种集合 集合中的对象不按特定的方式排序 并且没有重复对象
Set接口主要实现了两个实现类
HashSet : HashSet类按照哈希算法来存取集合中的对象 存取速度比较快
TreeSet : TreeSet类实现了SortedSet接口 能够对集合中的对象进行排序
Set 的用法
存放的是对象的引用 没有重复对象
Set set=new HashSet();
String s =new String( hello );
String s =s ;
String s =new String( world );
set add(s );
set add(s );
set add(s );
System out println(set size());//打印集合中对象的数目 为
Set 的 add()方法是如何判断对象是否已经存放在集合中?
boolean isExists=false;
Iterator iterator=erator();
while(it hasNext()) {
String oldStr=it next();
if(newStr equals(oldStr)){
isExists=true;
}
}
List(列表)
List的特征是其元素以线性方式存储 集合中可以存放重复对象
List接口主要实现类包括
ArrayList() : 代表长度可以改变得数组 可以对元素进行随机的访问 向ArrayList()中插入与
与删除元素的速度慢
LinkedList(): 在实现中采用链表数据结构 插入和删除速度快 访问速度慢
对于List的随机访问来说 就是只随机来检索位于特定位置的元素
List 的 get(int index) 方法放回集合中由参数index指定的索引位置的对象 下标从 开始
最基本的两种检索集合中的所有对象的方法
: 用for循环和get()方法
for(int i= ; i<list size();i++){
System out println(list get(i));
}
: 使用 迭代器(Iterator):
Iterator it=erator();
while(it hashNext){
System out println(it next);
}
Map(映射):
Map 是一种把键对象和值对象映射的集合 它的每一个元素都包含一对键对象和值对象
Map没有继承于Collection接口
从Map集合中检索元素时 只要给出键对象 就会返回对应的值对象
Map 的常用方法
添加 删除操作
Object put(Object key Object value): 向集合中加入元素
Object remove(Object key): 删除与KEY相关的元素
void putAll(Map t): 将来自特定映像的所有元素添加给该映像
void clear(): 从映像中删除所有映射
查询操作
Object get(Object key): 获得与关键字key相关的值
Map集合中的键对象不允许重复 也就说 任意两个键对象通过equals()方法比较的结果都是false
但是可以将任意多个键独享映射到同一个值对象上
Conllections : 集合实用类
Conllections提供了供JAVA集合实用的静态方法
总结
JAVA集合的基本用法 都归纳了 上面这些是平常最常用的JAVA集合 具体的其他的 还要参考JDK帮助文档了 呵呵 关于 Map的应用 还有很多 具体就是这个 Conllections提供了很多 List /Map 实用的方法 对平常开发非常有用
对次会会不断修改!
boolean containsKey(Object key): 判断映像中是否存在关键字key
boolean containsValue(Object value): 判断映像中是否存在值value
int size(): 返回当前映像中映射的数量
boolean isEmpty() 判断映像中是否有任何映射
List按对象进入的顺序保存对象 不做排序或编辑操作 Set对每个对象只接受一次 并使用自己内部的排序方法(通常 你只关心某个元素是否属于Set 而不关心它的顺序 否则应该使用List) Map同样对每个元素保存一份 但这是基于 键 的 Map也有内置的排序 因而不关心元素添加的顺序 如果添加元素的顺序对你很重要 应该使用 LinkedHashSet或者LinkedHashMap
List的功能方法
实际上有两种List: 一种是基本的ArrayList 其优点在于随机访问元素 另一种是更强大的LinkedList 它并不是为快速随机访问设计的 而是具有一套更通用的方法
List : 次序是List最重要的特点 它保证维护元素特定的顺序 List为Collection添加了许多方法 使得能够向List中间插入与移除元素(这只推荐LinkedList使用 )一个List可以生成ListIterator 使用它可以从两个方向遍历List 也可以从List中间插入和移除元素
ArrayList : 由数组实现的List 允许对元素进行快速随机访问 但是向List中间插入与移除元素的速度很慢 ListIterator只应该用来由后向前遍历ArrayList 而不是用来插入和移除元素 因为那比LinkedList开销要大很多
LinkedList : 对顺序访问进行了优化 向List中间插入与删除的开销并不大 随机访问则相对较慢 (使用ArrayList代替 )还具有下列方法 addFirst() addLast() getFirst() getLast() removeFirst() 和 removeLast() 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈 队列和双向队列使用
Set的功能方法
Set具有与Collection完全一样的接口 因此没有任何额外的功能 不像前面有两个不同的List 实际上Set就是Collection 只是行为不同 (这是继承与多态思想的典型应用 表现不同的行为 )Set不保存重复的元素(至于如何判断元素相同则较为负责)
Set : 存入Set的每个元素都必须是唯一的 因为Set不保存重复元素 加入Set的元素必须定义equals()方法以确保对象的唯一性 Set与Collection有完全一样的接口 Set接口不保证维护元素的次序
HashSet : 为快速查找设计的Set 存入HashSet的对象必须定义hashCode()
TreeSet : 保存次序的Set 底层为树结构 使用它可以从Set中提取有序的序列
LinkedHashSet : 具有HashSet的查询速度 且内部使用链表维护元素的顺序(插入的次序) 于是在使用迭代器遍历Set时 结果会按元素插入的次序显示
Map的功能方法
方法put(Object key Object value)添加一个 值 (想要得东西)和与 值 相关联的 键 (key)(使用它来查找) 方法get(Object key)返回与给定 键 相关联的 值 可以用containsKey()和containsValue()测试Map中是否包含某个 键 或 值 标准的Java类库中包含了几种不同的Map HashMap TreeMap LinkedHashMap WeakHashMap IdentityHashMap 它们都有同样的基本接口Map 但是行为 效率 排序策略 保存对象的生命周期和判定 键 等价的策略等各不相同
执行效率是Map的一个大问题 看看get()要做哪些事 就会明白为什么在ArrayList中搜索 键 是相当慢的 而这正是HashMap提高速度的地方 HashMap使用了特殊的值 称为 散列码 (hash code) 来取代对键的缓慢搜索 散列码 是 相对唯一 用以代表对象的int值 它是通过将该对象的某些信息进行转换而生成的 所有Java对象都能产生散列码 因为hashCode()是定义在基类Object中的方法
HashMap就是使用对象的hashCode()进行快速查询的 此方法能够显着提高性能
Map : 维护 键值对 的关联性 使你可以通过 键 查找 值
HashMap : Map基于散列表的实现 插入和查询 键值对 的开销是固定的 可以通过构造器设置容量capacity和负载因子load factor 以调整容器的性能
LinkedHashMap : 类似于HashMap 但是迭代遍历它时 取得 键值对 的顺序是其插入次序 或者是最近最少使用(LRU)的次序 只比HashMap慢一点 而在迭代访问时发而更快 因为它使用链表维护内部次序
TreeMap : 基于红黑树数据结构的实现 查看 键 或 键值对 时 它们会被排序(次序由Comparabel或Comparator决定) TreeMap的特点在于 你得到的结果是经过排序的 TreeMap是唯一的带有subMap()方法的Map 它可以返回一个子树
WeakHashMao : 弱键(weak key)Map Map中使用的对象也被允许释放: 这是为解决特殊问题设计的 如果没有map之外的引用指向某个 键 则此 键 可以被垃圾收集器回收
lishixin/Article/program/Java/ky/201311/27866
Ⅱ 怎样从java集合类set中取出数据
创建set的iterator方法:
Set<Object> set = new HashSet<Object>();
Iterator<Object> it = set.iterator();
while(it.hasNext())//判断是否有下一个
it.next()取出元素。
以上方法便是从Set集合中取出数据。
(2)java里的set扩展阅读:
Java中使用Set接口描述一个集合(集合不允许有“重复值”,注意重复的概念),集合Set是Collection的子接口,Set不允许其数据元素重复出现,也就是说在Set中每一个数据元素都是唯一的。Set接口定义的常用方法如下:
1、size() 获取Set尺寸(即Set包含数据元素的总数)。
2、 add(Object obj) 向Set中添加数据元素obj。
3、remove(Object obj) 从Set中移除数据元素obj。
4 、contains(Object obj) 判断当前Set中是否包含数据元素obj,如果包含返回true,否则返回false。
5、iterator() 将Set装入迭代器。
Ⅲ java中“get”和“set”方法怎么写
java bean就是把自己的数据成员封装起来, 让外界不能直接操作数据成员; 而只能通过bean提供的get 和 set方法进行操作,保证了数据安全性。可以理解为:get就是把对象中的值拿出来, set就是把某个值放到对象中去。
比如:
public class LoginInfoBean {
private String time; //时间
private String ip; //IP
private String account; // 账号
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public String getAccount() {
return account;
}
public void setAccount(String account) {
this.account = account;
}
}
---------------------------------------------------------------
关于如何在servlet中取得数据:
首先要明白,我们提交到servlet的数据,需要走servlet的doGet或者doPost方法。
如果你不用框架,只用纯粹的servlet,在servlet的doGet和doPost方法中因为只有两个参数,也就是HttpRequest和HttpResponse,比如:
doPost(HttpServletRequest req,
HttpServletResponse resp){
........
}
按照以上的写法,只能通过req.getParamter("xxx")取得;
比如下面这个例子:
file: login.jsp
<form id="loginform" name="loginform" method="post" action="LoginServlet" >
<input name="userName" type="text" id="userName" />
ps: 通过 action="LoginServlet" 可以知道,提交的路径为LoginServlet, 然后会到web.xml中寻找关于LoginServlet 的具体配置,以确定是哪个servlet处理这个请求。
file: web.xml
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.test.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/LoginServlet</url-pattern>
</servlet-mapping>
ps: 通过以上配置可以确定,处理这个请求的servlet为com.test.LoginServlet
file: com.test.LoginServlet.java
public void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
String name = request.getParameter("userName");
}
ps: 通过 request.getParameter("userName"); 就可以取得页面上输入的值。
如果用框架,每个框架的机制不一样,需要分别对待, 但底层也都是servlet。我接触过的struts1, struts2, 和spring MVC, 其中 struts1 给我们提供了一个formbean, 用于收集页面的数据(就是上面那个javabean的问题); struts2和spring MVC 省去了formbean, 后台处理的action就是一个bean, 数据在action中直接可以取到。
推荐一个简单的方法:写get/set方法,OC有一个自动化的方法,即使用@proterty和@synthesize关键字
Person.h
Ⅳ java中的get 和set 是什么意思
get成员方法和set成员方法分别用于读取和设置私有变量的值
一般建议将有特殊限制的成员域的访问控制方式设置为私有模式。这时,可以添加两个成员方法分别读取和设置这个具有特殊限制的成员域的值。在这两个成员方法中,由于读取该成员域的值的成员方法的名称通常含有字符序列“get”,因此该成员方法通常简称为“get”成员方法;而设置该成员域的值的成员方法的名称通常含有字符序列“set”,因此该成员方法通常简称为“set”成员方法。
这样可以加强程序的封装性和安全性,外部程序不能直接访问私有变量,只能通过get成员方法和set成员方法读取和设置私有变量的值。
如:
Ⅳ java set 顺序
在java语言中,提供多种不同的结构来组织对象,Set(集合)是其中的一种,本身是一个接口,其迭代时的顺序取决于其具体实现。典型的实现包括:
HashSet:哈希表是通过使用称为散列法的机制来存储信息的,元素并没有以某种特定顺序来存放;
LinkedHashSet:以元素插入的顺序来维护集合的链接表,允许以插入的顺序在集合中迭代;
TreeSet:提供一个使用树结构存储Set接口的实现,对象以升序顺序存储,访问和遍历的时间很快。
(5)java里的set扩展阅读
Set<String> set = new TreeSet<String>();
set.add("f");
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("e");
System.out.println(set);
Ⅵ java中怎么往集合类set里添加数据
java中往集合添加数据调用add();方法就行
//第一步先创建一个set集合的子类
HashSet has=new HashSet<>();
//给set集合添加的方法是add();
has.add(args);
Collection接口可以存放重复元素,也可以存放不重复元素。List可以存放重复元素,Set就是不重复的元素。
通过元素的equals方法,来判断是否为重复元素。
Set集合取出元素的方式可以采用:迭代器,增强 for
Ⅶ Java中set什么意思
setLayout 设置此容器的布局管理器,也就是给界面布局
Jdk 就是这样定义的,这个没有什么喜欢不喜欢,而且用set具有易读性
Ⅷ java中 List 与Set 有什么区别
Java的集合类都位于java.util包中,Java集合中存放的是对象的引用,而非对象本身。
Java集合主要分为三种类型:
a.Set(集):集合中的对象不按特定方式排序,并且没有重复对象。它的有些实现类能对集合中的对象按特定方式排序。
b.List(列表):集合中的对象按索引位置排序,可以有重复对象,允许按照对象在集合中的索引位置检索对象。
c.Map(映射):集合中的每一个元素包含一对键对象和值对象,集合中没有重复的键对象,值对象可以重复。它的有些实现类能对集合中的键对象进行排序。
Set、List和Map统称为Java集合。
1.Set(集)
Set集合中的对象不按特定方式排序,并且没有重复对象。Set接口主要有两个实现类HashSet和TreeSet。HashSet类按照哈希算法来存取集合中的对象,存取速度比较快。HashSet类还有一个子类LinkedHashSet类,它不仅实现了哈希算法,而且实现了链表数据结构。TreeSet类实现了SortedSet接口,具有排序功能。
Set的add()方法判断对象是否已经存在于集合中的判断流程:
boolean isExists = false;
Iterator it = set.iterator();
while(it.hasNext()){
Object object = it.next();
if(newObject.equals(oldObject)){
isExists = true;
break;
}
}
2.HashSet类
当HashSet向集合中加入一个对象时,会调用对象的hashCode()方法获得哈希码,然后根据这个哈希码进一步计算出对象在集合中的存放位置。
当Object1变量和object2变量实际上引用了同一个对象,那么object1和object2的哈希码肯定相同。
为了保证HashSet能正常工作,要求当两个对象用equals()方法比较的结果为相等时,它们的哈希码也相等。即:
customer1.hashCode() == customer2.hashCode();
如:对应于Customer类的以下重写后的equals()方法:
public boolean equals(Object o){
if(this==o) return true;
if(!o instanceof Customer) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge())
return true;
else
return false;
}
为了保证HashSet正常工作,如果Customer类覆盖了equals()方法,也应该覆盖hashCode()方法,并且保证两个相等的Customer对象的哈希码也一样。
public int hashCode(){
int result;
result = (name==null?0:name.hashCode());
result = 29*result+(age==null?0:age.hashCode());
return result;
}
3.TreeSet类
TreeSet类实现了SortedSet接口,能够对集合中的对象进行排序。TreeSet支持两种排序方式:自然排序和客户化排序,在默认情况下TreeSet采用自然排序方式。
a.自然排序
在JDK中,有一部分类实现了Comparable接口,如Integer、Double和String等。Comparable接口有一个compareTo(Object o)方法,它返回整数类型。对于表达式x.compareTo(y),如果返回值为0,表示x和y相等,如果返回值大于0,表示x大于y,如果返回值小于0,表示x小于y。
TreeSet调用对象的compareTo()方法比较集合中对象的大小,然后进行升序排列,这种排序方式称为自然排序。
以下列出了JDK中实现了Comparable接口的一些类的排序方式
类 排序
BigDecimal\BigInteger\Byte\Double\Float\Integer\Long\Short 按数字大小排序
Character 按字符的Unicode值的数字大小排序
String 按字符串中字符的Unicode值排序
使用自然排序时,只能向TreeSet集合中加入同类型的对象,并且这些对象的类必须实现了Comparable接口,否则会在第二次调用TreeSet的add()方法时,会抛出ClassCastException异常。
例如:
以下是Customer类的compareTo()方法的一种实现方式:
public int compareTo(Object o){
Customer other = (Customer)o;
//先按照name属性排序
if(this.name.compareTo(other.getName())>0) return 1;
if(this.name.compareTo(other.getName())<0) return -1;
//再按照age属性排序
if(this.age>other.getAge()) return 1;
if(this.age<other.getAge()) return -1;
return 0;
}
为了保证TreeSet能正确地排序,要求Customer类的compareTo()方法与equals()方法按相同的规则比较两个Customer对象是否相等。
因此在Customer类的equals()方法中应该采用相同的比较规则:
public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Customer)) return false;
final Customer other = (Customer)o;
if(this.name.equals(other.getName())&&this.age==other.getAge()){
return true;
}else{
return false;
}
}
值得注意的是,对于TreeSet中已经存在的Customer对象,如果修改了它们的属性,TreeSet不会对集合进行重新排序。在实际域模型中,实体类的属性可以被更新,因此不适合通过TreeSet来排序。最适合于排序的是不可变类。
b.客户化排序
除了自然排序,TreeSet还支持客户化排序。java.util.Comparator接口用于指定具体的排序方式,它有个compare(Object object1,Object object2)方法,用于比较两个对象的大小。当表达式compare(x,y)的值大于0,表示x大于y;当compare(x,y)的值小于0,表示x小于y;当compare(x,y)的值等于0,表示x等于y。
例如:如果希望TreeSet仅按照Customer对象的name属性进行降序排列,可以创建一个实现Comparator接口的类CustomerComparator:
public class CustomerComparator implements Comparator{
public int compare(Object o1,Object o2){
Customer c1= (Customer)o1;
Customer c2 = (Customer)o2;
if(c1.getName().compareTo(c2.getName())>0) return -1;
if(c2.getName().compareTo(c2.getName())<0) return 1;
return 0;
}
}
接下来在构造TreeSet的实例时,调用它的TreeSet(Comparator comparator)构造方法:
Set set = new TreeSet(new CustomerComparator());
4.向Set中加入持久化类的对象
例如两个Session实例从数据库加载相同的Order对象,然后往HashSet集合里存放,在默认情况下,Order类的equals()方法比较两个Orer对象的内存地址是否相同,因此order1.equals(order2)==false,所以order1和order2游离对象都加入到HashSet集合中,但实际上order1和order2对应的是ORDERS表中的同一条记录。对于这一问题,有两种解决方案:
(1)在应用程序中,谨慎地把来自于不同Session缓存的游离对象加入到Set集合中,如:
Set orders = new HashSet();
orders.add(order1);
if(!order2.getOrderNumber().equals(order1.getOrderNumber()))
order.add(order2);
(2)在Order类中重新实现equals()和hashCode()方法,按照业务主键比较两个Order对象是否相等。
提示:为了保证HashSet正常工作,要求当一个对象加入到HashSet集合中后,它的哈希码不会发生变化。
5.List(列表)
List的主要特征是其对象以线性方式存储,集合中允许存放重复对象。List接口主要的实现类有LinkedList和ArrayList。LinkedList采用链表数据结构,而ArrayList代表大小可变的数组。List接口还有一个实现类Vector,它的功能和ArrayList比较相似,两者的区别在于Vector类的实现采用了同步机制,而ArrayList没有使用同步机制。
List只能对集合中的对象按索引位置排序,如果希望对List中的对象按其他特定方式排序,可以借助Comparator和Collections类。Collections类是集合API中的辅助类,它提供了操纵集合的各种静态方法,其中sort()方法用于对List中的对象进行排序:
a.sort(List list):对List中的对象进行自然排序。
b.sort(List list,Comparator comparator):对List中的对象进行客户化排序,comparator参数指定排序方式。
如Collections.sort(list);
6.Map(映射)
Map(映射)是一种把键对象和值对象进行映射的集合,它的每一个元素都包含一对键对象和值对象,而值对象仍可以是Map类型,依次类推,这样就形成了多级映射。
Map有两种比较常用的实现:HashMap和TreeMap。HashMap按照哈希算法来存取键对象,有很好的存取性能,为了保证HashMap能正常工作,和HashSet一样,要求当两个键对象通过equals()方法比较为true时,这两个对象的hashCode()方法返回的哈希码也一样。
TreeMap实现了SortedMap接口,能对键对象进行排序。和TreeSet一样,TreeMap也支持自然排序和客户化排序两种方式。
例:创建一个缓存类EntityCache,它能粗略地模仿Session的缓存功能,保证缓存中不会出现两个OID相同的Customer对象或两个OID相同的Order对象,这种惟一性是由键对象的惟一性来保证的。
Key.java:
package mypack;
public class Key{
private Class classType;
private Long id;
public Key(Class classType,Long id){
this.classType = classType;
this.id = id;
}
public Class getClassType(){
return this.classType;
}
public Long getId(){
return this.id;
}
public boolean equals(Object o){
if(this==o) return true;
if(!(o instanceof Key)) return false;
final Key other = (Key)o;
if(classType.equals(other.getClassType())&&id.equals(other.getId()))
return true;
return false;
}
public int hashCode(){
int result;
result = classType.hashCode();
result = 29 * result + id.hashCode();
return result;
}
}
EntityCache.java:
package mypack;
import java.util.*;
public class EntityCache {
private Map entitiesByKey;
public EntityCache() {
entitiesByKey=new HashMap();
}
public void put(BusinessObject entity){
Key key=new Key(entity.getClass(),entity.getId());
entitiesByKey.put(key,entity);
}
public Object get(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.get(key);
}
public Collection getAllEntities(){
return entitiesByKey.values();
}
public boolean contains(Class classType,Long id){
Key key=new Key(classType,id);
return entitiesByKey.containsKey(key);
}
}