JAVA集合之Map映射深刻总结案例附上解释跟总结
Java集合系列之Map映射学习总结一．HashMap实例
案例1：HashMapDemo1
package Map映射;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* 顺序结构
* 基于哈希表的Map 接口的实现。
* 键和值都允许是null,值可以重复。
* 无序的
* 线程不安全的。（不同步）
* 遍历无序输出.
* 和Set集一样，没有for循环遍历的方法。
* 遍历Map方法有两种：
* ①调用keySet方法：
* Set keys = map.keySet();
* Iterator it = keys.iterator();
* ②调用entrySet方法：
* Set keys = map.entrySet();
* Iterator it = keys.iterator();
* 本例子遍历的是基本类型
*
*/
public class HashMapDemo1 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put(1, 111);
map.put("1", "上海");
map.put(5, "广州");
map.put(3, "西安");
map.put(null,"武汉"); //键允许是null
map.put(2, null);//值允许是null
map.put(null,null);//键和值都允许是null,会替换前面的null:武汉.
System.out.println("**********迭代器遍历调用keySet方法*********");
Set keys = map.keySet();//获取所有的键，放入一个集合中
Iterator it = keys.iterator();//取得迭代器才可以遍历
//遍历出来的结果是无序的。
while(it.hasNext())
{
Object obj = it.next();//切记这个至少遍历键，不是值。
System.out.println(obj+"------>"+map.get(obj));//取得键对应的值
}
System.out.println("**********迭代器遍历调用entrySet方法*********");
Set set1=map.entrySet();
Iterator iterator1=set1.iterator();
while (iterator1.hasNext()) {
Map.Entry object = (Map.Entry) iterator1.next();
System.out.println(object.getKey()+"------>"+object.getValue());
}
}
}
案例2：HashMapDemo2
package Map映射;
import java.util.*;
public class HashMapDemo2 {
@SuppressWarnings("rawtypes")
public static void main(String[] args){
HashMap
HashMap
Person2 p1=new Person2("李川",111,80);
Person2 p2=new Person2("李您",111,80);
Person2 p3=new Person2("林是",111,80);
map1.put(1, p1);
map1.put(2, p2);
map1.put(3, p3);
map.put(1, 110);
map.put(2, 220);
map.put("城市","福建");
map.put(null, null);
System.out.println("***********用keySet方法遍历*********");
Set keys=map.keySet();//取得键值，取得map所有的键值，存入set集合中
Iterator iterator=keys.iterator();//利用键值取得value值
while(iterator.hasNext()){
Object object=iterator.next();
System.out.println(object+"------->"+map.get(object));//输出是无序的
}
System.out.println("***********用entrySet方法遍历*********");
Set
Iterator
while(iterator1.hasNext()){
Map.Entry
// entry.getValue();表示取得该键对应的值，这个值要是基本类型的话，那就直接输出，要是引用类型的话，还需要调用方法取得相应的值
System.out.println((entry.getKey()+"------->"+"姓名：
"+(entry.getValue()).getname()+"学号："+(entry.getValue()).getno()+"分数："+(entry.getValue()).getscore()));//输出是无序的
}
}
}
class Person2{
String name;
int no;
int score;
public Person2(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
}
案例3：HashMapDemo3
package Map映射;
/**
*总结：HashMap用entrySet()方法遍历用法：
*①Set
*②Iterator
*③iterator.hasNext();判断是否有键
*④Map.Entry
*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。
*注意了，对于entry.getValue()，若是基本数据怎么不需要改变，若是引用类型：
*Person3 p=(Person3) entry.getValue();
*System.out.println(entry.getKey()+"---->"+pp.getname());
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo3 {
public static void main(String args[]){
HashMap
Person3 p1=new Person3("李川",111,80);
Person3 p2=new Person3("李川",111,80);
Person3 p3=new Person3("李川",111,80);
map3.put(1,11);
map3.put(2, 110);
map3.put(3, 220);
map3.put(6, p1);
map3.put(4,"福建");
map3.put(5, 'a');
map3.put(null, null);
map3.put(7, p2);
map3.put(8, p3);
map3.remove(6);
Set
Iterator
while (iterator.hasNext()) {
Map.Entry
if(entry.getValue() instanceof Person3){//entry.getValue()这是表示值，但是对应的是引用类型对象
Person3 pp=(Person3) entry.getValue();
System.out.println(entry.getKey()+"---->"+pp.getname());
}
else {
System.out.println(entry.getKey()+"----"+entry.getValue());
}
}
}
}
class Person3{
String name;
int no;
int score;
public Person3(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
}
案例4：HashMapDemo4
package Map映射;
/**
* 总结：HashMap用keySet方法遍历用法：
* ①Set set=map4.keySet();调用keySet方法，将所有集合中的键放入set集合中
* ②Iterator iterator=set.iterator();取得迭代器，用来遍历集合中的键
* ③iterator.hasNext()判断是否有键
* ④Object object =iterator.next();遍历第一个键
* ⑤map4.get(object);取得键对应的值。记住这个值可以是基本类型，也可以是引用类型*/
import java.util.*;
public class HashMapDemo4 {
public static void main(String args[]){
HashMap
Person4 p1=new Person4("李川",111,80);
Person4 p2=new Person4("李川",111,80);
Person4 p3=new Person4("李川",111,80);
map4.put(1,22);
map4.put(2, "ddd");
map4.put(3, 'a');
map4.put(4, p1);
map4.put(6, p2);
map4.put(null,null);
map4.put(5, p3);
Set set=map4.keySet();
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Object object =iterator.next();
if(map4.get(object) instanceof Person4){
Person4 pp=(Person4)map4.get(object);
//System.out.println(object+"----->"+pp.getname()+"---"+pp.getno()+"----"+pp.getscore());
System.out.println(object+"--->"+pp);
}
else {
System.out.println(object+"---->"+map4.get(object));
}
}
}
}
class Person4{
String name;
int no;
int score;
public Person4(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
public String toString(){
return "姓名:"+https://www.360docs.net/doc/7916360298.html,;
}
}
总结：
package Map映射;
/**
* HashMap特点：
* 键-值都允许为null值
* 顺序结构，但是遍历输出是排序输出的
* 基于哈希表的 Map 接口的实现。
* 键和值都允许是null,值可以重复。
* 无序的，也就是输出不会按顺序输出,排序输出
* 线程不安全的。（不同步）
*
* 掌握好两种遍历方法：
* 一.总结：HashMap用entrySet()方法遍历用法：
*①Set
*②Iterator
*③iterator.hasNext();判断是否有键
*④Map.Entry
*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。
*注意了，对于entry.getValue()，若是基本数据怎么不需要改变，若是引用类型：
*Person3 p=(Person3) entry.getValue();
*System.out.println(entry.getKey()+"---->"+pp.getname());
*
*
*
*
*二.总结：HashMap用keySet方法遍历用法：
* ①Set set=map4.keySet();调用keySet方法，将所有集合中的键放入set集合中
* ②Iterator iterator=set.iterator();取得迭代器，用来遍历集合中的键
* ③iterator.hasNext()判断是否有键
* ④Object object =iterator.next();遍历第一个键
* ⑤map4.get(object);取得键对应的值。记住这个值可以是基本类型，也可以是引用类型
*
*/
二．HashTable实例
案例1：HashtableDemo1
package Map映射;
/**
*
* 基于哈希表的Map 接口的实现。
* 键和值都不允许是null,值可以重复。
* 线程安全的。（同步的）
* 遍历无序输出的
*
*/
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class HashtableDemo1 {
public static void main(String[] args) {
Hashtable map = new Hashtable();
map.put(4, "广州");
map.put(1, "北京");
map.put("1", "上海");
map.put(5, "广州");
map.put(3, "西安");
map.put("a", "西安");
map.put("d", "西安");
map.put("b", "西安");
map.put(1, "西安");
map.put(2, "西安");
map.put(6, "西安");
//map.put(null,"武汉"); //键不允许是null
//map.put(2, null);//值不允许是null
//map.put(null,null);//键和值都不允许是null.
System.out.println("***************keySet()方法遍历**********");
Set keys = map.keySet();
Iterator it = keys.iterator();
//遍历出来的结果是无序的。
while(it.hasNext())
{
Object obj = it.next();
System.out.println(obj+"="+map.get(obj));
}
System.out.println("***************entrySet()方法遍历**********");
Set set=map.entrySet();
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Map.Entry entry=(Map.Entry) iterator.next();
System.out.println(entry.getKey()+"---->"+entry.getValue());
}
}
}
案例2：
package Map映射;
/**
* 基于哈希表的Map 接口的实现。
* 键和值都不允许是null,值可以重复。
* 线程安全的。（同步的）
* 遍历无序输出的
*/
import java.util.*;
import java.util.Map.Entry;
public class HashtableDemo2 {
public static void main(String args[]){
Hashtable
Person5 p1=new Person5("李川",111,80);
Person5 p2=new Person5("李四",111,80);
Person5 p3=new Person5("李五",111,80);
map4.put(1,22);
map4.put(2, "ddd");
map4.put(3, 'a');
map4.put(4, p1);
map4.put(6, p2);
//map4.put(null,null);Hashtable的键-值都不允许为null
map4.put(5, p3);
System.out.println("************用keySet方法遍历**************");
Set set=map4.keySet();
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Object object =iterator.next();
if(map4.get(object) instanceof Person4){
Person4 pp=(Person4)map4.get(object);
//System.out.println(object+"----->"+pp.getname()+"---"+pp.getno()+"----"+pp.getscore());
System.out.println(object+"--->"+pp);
}
else {
System.out.println(object+"---->"+map4.get(object));
}
}
System.out.println("************用entrySet方法遍历**************");
Set set1=map4.entrySet();
Iterator iterator2=set1.iterator();
while (iterator2.hasNext()) {
Map.Entry entry=(Map.Entry) iterator2.next();
if(entry.getValue() instanceof Person4){
Person4 p=(Person4)entry.getValue();
System.err.println(entry.getKey()+"-----"+p.getname());}
else {
System.err.println(entry.getKey()+"----"+entry.getValue());
}
}
}
}
class Person5{
String name;
int no;
int score;
public Person5(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
public String toString(){
return "姓名:"+https://www.360docs.net/doc/7916360298.html,;
}
}
package Map映射;
/**
* 总结：Hashtable的遍历方法和Hashtable的遍历方法差不多的
* 基于哈希表的 Map 接口的实现。
* 键和值都不允许是null,值可以重复。
* 线程安全的。（同步的）
* 遍历无序输出的
*
*
*掌握好两种遍历方法：
* 一.总结：Hashtable用entrySet()方法遍历用法：
*①Set
*②Iterator
*③iterator.hasNext();判断是否有键
*④Map.Entry
*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。
*注意了，对于entry.getValue()，若是基本数据怎么不需要改变，若是引用类型：
*Person3 p=(Person3) entry.getValue();
*System.out.println(entry.getKey()+"---->"+pp.getname());
*
*
*
*
*二.总结：Hashtable用keySet方法遍历用法：
* ①Set set=map4.keySet();调用keySet方法，将所有集合中的键放入set集合中
* ②Iterator iterator=set.iterator();取得迭代器，用来遍历集合中的键
* ③iterator.hasNext()判断是否有键
* ④Object object =iterator.next();遍历第一个键
* ⑤map4.get(object);取得键对应的值。记住这个值可以是基本类型，也可以是引用类型
*
*/
三．LinkedHashMap实例
案例1：LinkedHashMapDemo1
package Map映射;
/**
* 键和值都允许是null,键不允许重复,值可以重复。
* 线程不安全的。（不同步）
* 遍历输出的结果是按顺序输出的
* 该例子遍历的是基本类型
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class LinkedHashMapDemo1 {
public static void main(String[] args) {
LinkedHashMap map = new LinkedHashMap();
map.put(1, "北京");
map.put("1", "上海");
map.put(3, "广州");
map.put(5, "西安");
map.put(null,"武汉"); //键允许是null
map.put(2, null);//值允许是null
map.put(null,null);//键和值都允许是null,会替换前面的null:武汉.
System.out.println("************用keySet遍历*********");
Set keys = map.keySet();
Iterator it = keys.iterator();
//遍历出来的结果是顺序的。
while(it.hasNext())
{
Object obj = it.next();
System.out.println(obj+"="+map.get(obj));
}
System.out.println("************用entrySet遍历*********");
Set set=map.entrySet();
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Map.Entry entry=(Map.Entry)iterator.next();
System.err.println(entry.getKey()+"--->"+entry.getValue());
}
}
}
案例2：LinkedHashMapDemo2
package Map映射;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* 键和值都允许是null,键不允许重复,值可以重复。
* 线程不安全的。（不同步）
* 遍历输出的结果是按顺序输出的
* 该例子遍历的是基本类型和引用类型
*
*/
public class LinkedHashMapDemo2 {
public static void main(String args[]){
LinkedHashMap map3=new LinkedHashMap();
Person11 p1=new Person11("李川",111,80);
Person11 p2=new Person11("李四",111,80);
Person11 p3=new Person11("李五",111,80);
map3.put(1,11);
map3.put(2, 110);
map3.put(3, 220);
map3.put(6, p1);
map3.put(4,"福建");
map3.put(5, 'a');
map3.put(null, null);
map3.put(7, p2);
map3.put(8, p3);
System.out.println("*****keySet方法遍历*******");
Set set=map3.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
Object object=iterator.next();//需要注意的是键还是值
if(map3.get(object) instanceof Person11){
Person11 p=(Person11)map3.get(object);
System.out.println(object+"-->"+p.getname());
}
else {
System.out.println(object+"---->"+map3.get(object));
}
}
System.out.println("*****entrySet方法遍历*******");
Set set1=map3.entrySet();
Iterator iterator1=set1.iterator();
while(iterator1.hasNext()){
Map.Entry entry=(Entry) iterator1.next();
if(entry.getValue() instanceof Person11){
Person11 person11=(Person11) entry.getValue();
System.err.println(entry.getKey()+"-->"+person11.getname());
}
else {
System.err.println(entry.getKey()+"--->"+entry.getValue());
}
}
}
}
class Person11{
String name;
int no;
int score;
public Person11(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
}
总结：package Map映射;
/**特点：
* 离散结构
* 基于哈希表的 Map 接口的实现。
* 键和值都允许是null,值可以重复。
* 有序的
* 线程不安全的。（不同步）
* 遍历输出的结果是按顺序输出的
*
*
*
*
* 掌握好两种遍历方法：
* 一.总结：LinkedHashMap用entrySet()方法遍历用法：
*①Set
*②Iterator
*③iterator.hasNext();判断是否有键
*④Map.Entry
*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。
*注意了，对于entry.getValue()，若是基本数据怎么不需要改变，若是引用类型：
*Person3 p=(Person3) entry.getValue();
*System.out.println(entry.getKey()+"---->"+pp.getname());
*
*
*
*
*二.总结：LinkedHashMap用keySet方法遍历用法：
* ①Set set=map4.keySet();调用keySet方法，将所有集合中的键放入set集合中
* ②Iterator iterator=set.iterator();取得迭代器，用来遍历集合中的键
* ③iterator.hasNext()判断是否有键
* ④Object object =iterator.next();遍历第一个键
* ⑤map4.get(object);取得键对应的值。记住这个值可以是基本类型，也可以是引用类型
*
*/
三．TreeMap实例
案例1：TreeMapDemo1
package Map映射;
/**
* 键不允许是null，并且数据类型一致,值允许是null。
* 实现自然排序
* 线程不安全。（不同步）
* 遍历排序输出
*/
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo1 {
public static void main(String[] args) {
TreeMap
map.put(1, "北京");
//map.put(null, "杭州");键不允许是null,
map.put(4, null);//值允许为null
//map.put("1", "上海");//错误，要求键的数据类型必须一致。
map.put(5, "广州");
map.put(3, "西安");
System.out.println("******keySet方法调用****");
Set
Iterator
//遍历出来的结果是自然排序的。
while(it.hasNext())
{
Object obj = it.next();
System.out.println(obj+"="+map.get(obj));
}
System.out.println("*******entrySet方法调用*******");
Set set1=map.entrySet();
Iterator iterator=set1.iterator();
while (iterator.hasNext()) {
Map.Entry object = (Map.Entry) iterator.next();
System.err.println(object.getKey()+"--->"+object.getValue());
}
}
}
案例2：
package Map映射;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
* 键和值都允许是null,键不允许重复,值可以重复。
* 线程不安全的。（不同步）
* 遍历输出的结果是按顺序输出的
* 该例子遍历的是基本类型和引用类型
*
*/
public class TreeMapDemo2 {
public static void main(String args[]){
TreeMap map3=new TreeMap();
Person121 p1=new Person121("李川",111,80);
Person121 p2=new Person121("李四",111,80);
Person121 p3=new Person121("李五",111,80);
map3.put(1,11);
map3.put(2, 110);
map3.put(3, 220);
map3.put(6, p1);
//map3.put("3","福建");键要求数据类型一致
map3.put(5, 'a');
map3.put(0, null);//键不允许是null值
map3.put(7, p2);
map3.put(8, p3);
System.out.println("*****keySet方法遍历*******");
Set set=map3.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext()){
Object object=iterator.next();//需要注意的是键还是值
if(map3.get(object) instanceof Person11){
Person11 p=(Person11)map3.get(object);
System.out.println(object+"-->"+p.getname());
}
else {
System.out.println(object+"---->"+map3.get(object));
}
}
System.out.println("*****entrySet方法遍历*******");
Set set1=map3.entrySet();
Iterator iterator1=set1.iterator();
while(iterator1.hasNext()){
Map.Entry entry=(Entry) iterator1.next();
if(entry.getValue() instanceof Person11){
Person11 person11=(Person11) entry.getValue();
System.err.println(entry.getKey()+"-->"+person11.getname());
}
else {
System.err.println(entry.getKey()+"--->"+entry.getValue());
}
}
}
}
class Person121{
String name;
int no;
int score;
public Person121(String name,int no,int score){
https://www.360docs.net/doc/7916360298.html,=name;
this.no=no;
this.score=score;
}
public void setname(String name){
https://www.360docs.net/doc/7916360298.html,=name;
}
public void setno(int no){
this.no=no;
}
public void setscore(int score){
this.score=score;
}
public String getname(){
return name;
}
public int getno(){
return no;
}
public int getscore(){
return score;
}
}
总结：package Map映射;
/**
* 键不允许是null，并且数据类型一致,值允许是null。
* 实现自然排序
* 线程不安全。（不同步）
* 遍历排序输出
* 要理解好数据类型一致怎么回事
*
*
*
*
* 掌握好两种遍历方法：
* 一.总结：TreeMap用entrySet()方法遍历用法：
*①Set
*②Iterator
*③iterator.hasNext();判断是否有键
*④Map.Entry
*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。
*注意了，对于entry.getValue()，若是基本数据怎么不需要改变，若是引用类型：
*Person3 p=(Person3) entry.getValue();
*System.out.println(entry.getKey()+"---->"+pp.getname());
*
*
*
*
*二.总结：TreeMap用keySet方法遍历用法：
* ①Set set=map4.keySet();调用keySet方法，将所有集合中的键放入set集合中
* ②Iterator iterator=set.iterator();取得迭代器，用来遍历集合中的键
* ③iterator.hasNext()判断是否有键
* ④Object object =iterator.next();遍历第一个键
* ⑤map4.get(object);取得键对应的值。记住这个值可以是基本类型，也可以是引用类型
*
*/
javaweb开发要学习的所有技术和框架总结：
学习javaweb开发要学习的技术和框架总结： 前言：当初想学习javaweb开发的时候，希望能够全方面地学习（这样找工作时就胸有成足了）。但是对这个根本不理解，又不认识从事这方面的熟人，所以学习起来无从下手。经过了一年的‘死’学习，从网上，从书本，从视频里面深入了解了java。想从事java的朋友，只要把这些技术全学会了，哪就业肯定没有问题了。 前端技术： HTML, CSS, JA V ASCRIPT, JQUERY, AJAX HTML “超文本”就是指页面内可以包含图片、链接，甚至音乐、程序等非文字元素。 超文本标记语言的结构包括“头”部分（外语：Head）、和“主体”部分（外语：Body），其中“头”部提供关于网页的信息，“主体”部分提供网页的具体内容。 CSS 级联样式表是一种用来表现HTML（标准通用标记语言的一个应用）或XML（标准通用标记语言的一个子集）等文件样式的计算机语言。 JavaScript JavaScript一种直译式脚本语言，是一种动态类型、弱类型、基于原型的语言，内置支持类型。它的解释器被称为JavaScript引擎，为浏览器的一部分，广泛用于客户端的脚本语言，最早是在HTML（标准通用标记语言下的一个应用）网页上使用，用来给HTML网页增加动态功能。 jQuery jQuery是一个兼容多浏览器的javascript库，核心理念是write less,do more(写得更少,做得更多)。jQuery在2006年1月由美国人John Resig在纽约的barcamp发布，吸引了来自世界各地的众多JavaScript高手加入，由Dave Methvin率领团队进行开发。如今，jQuery已经成为最流行的javascript库，在世界前10000个访问最多的网站中，有超过55%在使用jQuery。
java中Map类
java中Map类 Map以按键/数值对的形式存储数据，和数组非常相似，在数组中存在的索引，它们本身也是对象。 Map的接口 Map－－－实现Map Map.Entry－－Map的内部类，描述Map中的按键/数值对。 SortedMap---扩展Map，使按键保持升序排列 关于怎么使用，一般是选择Map的子类，而不直接用Map类。 下面以HashMap为例。 public static void main(String args[]) { HashMap hashmap = new HashMap(); hashmap.put("Item0", "Value0"); hashmap.put("Item1", "Value1"); hashmap.put("Item2", "Value2"); hashmap.put("Item3", "Value3"); Set set = hashmap.entrySet(); Iterator iterator = set.iterator(); while (iterator.hasNext() { Map.Entry mapentry = (Map.Entry) iterator.next(); System.out.println(mapentry.getkey() + "/" + mapentry.getValue()); } } 注意，这里Map的按键必须是唯一的，比如说不能有两个按键都为null。 如果用过它，就会知道它的用处了。 又比如: Map
Java集合类知识点总结
Java集合类 Java集合类 (1) 1.Map (3) 1.1.HashMap (3) 1.1.1.底层实现 (3) 1.1.2.特点 (3) 1.1.3.源码分析 (4) 1.1.4.多线程可能出现的问题 (5) 1.2.ConcurrentHashMap (6) 1.2.1.底层实现 (6) 1.2.2.源码分析 (7) 1.3.HashTable (9) 1.3.1.HashTable是线程安全的，因为所有方法上都加了synchronized关键 字。9 1.3.2.HashTable的key和value都不可以为null。 (9) 1.3.3.扩容时，capacity=2*capacity+1 (9) 1.3.4.数组默认大小为11 (9) 1.3.5.查找下标时，没有使用hash&length-1，而是直接进行计算的 (9) 1.4.TreeMap (9) 1.4.1.底层实现为红黑树 (9) 1.4. 2.TreeMap是一个有序的key-value集合，基于红黑树实现。该映射根据 其键的自然顺序进行排序，或者根据创建时提供的Comparator进行排序 (10) 1.4.3.接口实现 (10) 1.4.4.Entry (11) 1.5.LinkedHashMap (11) 1.5.1.底层是数组+链表+红黑树+双向链表 (11) 1.5.2.维护链表顺序和访问顺序 (11) 1.5.3.LinkedHashMap 可以通过构造参数 accessOrder 来指定双向链表是否在 元素被访问后改变其在双向链表中的位置。 (11) 1.5.4.当accessOrder为true时，get方法和put方法都会调用recordAccess 方法使得最近使用的Entry移到双向链表的末尾；当accessOrder为默认值 false时，recordAccess方法什么也不会做。 (11) 1.5.5.LRU实现 (11) 2.Collection (11) 2.1.List (12) 2.1.1.ArrayList (12) 2.1.2.LinkedList (13) 2.1.3.CopyOnWriteArrayList (13) 2.2.Set (14) 2.2.1.HashSet (14)
JAVA框架面试题汇总
1.SpringMVC Framework的理解： 1、它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件。并且和Spring提供的其他基础结构紧密集成 2、不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的) 3、可以任意使用各种视图技术,而不仅仅局限于JSP 4、支持各种请求资源的映射策略 5、它应是易于扩展的 2.简单的谈一下SpringMVC的工作流程？ 流程? 1、用户发送请求至前端控制器DispatcherServlet? 2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。? 3、处理器映射器找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。? 4、DispatcherServlet调用HandlerAdapter处理器适配器? 5、HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。? 6、Controller执行完成返回ModelAndView? 7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet? 8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器? 9、ViewReslover解析后返回具体View? 10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。? 11、DispatcherServlet响应用户 3.如何解决POST请求中文乱码问题，GET的又如何处理呢？ 在web.xml中加入： .
集合里Map,Set,List的区别
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类按照哈希算法来存取集合中的对象，存取速度比较快
Java三大框架(ssh)总结
Hibernate框架 第一章数据结构 1.1认识数据结构 数据：是信息的载体，是能够被计算机识别、存储、计算的符号集合是计算机处理的对象的总称； 数据元素：也称为结点，是组成数据的基本单位； 数据项：是数据的最小单位； 数据对象：是具有相同特征的数据元素的集合，它是数据的子集； 数据结构：计算机存储、组织数据的方式； ●逻辑结构：指从逻辑关系上描述数据，与数据的存储无关，且独立于语言； ?线性结构：有且仅有一个开始结点和一个终端结点，所有结点最多只有一个前驱 结点和一个直接后继结点； ?非线性结构：指一个结点可能有多个直接前驱和直接后继结点。 ●存储结构：指数据元素及其关系在计算机存储时如何表示，依赖于语言； ●数据运算：通茶昂贵定义在数据的逻辑结构上。 1.2算法 是为求解一个问题需要遵循的，被清晰的制定的简单指令的集合；正确的算法有如下特点： ●用待处理问题的相关信息作为输入数据 ●对一个既定的合法输入，多次执行同一算法，总返回同一个结果（随机算法除外） ●算法中的指令是可行的，即每个指令都可以实现 ●算法中指令的数量是有限的 ●算法执行完毕后，能够输出正确的数据集合 1.3算法分析 目的在于选择合适的算法，算法分析是从复杂度来考虑的。复杂度：衡量一个算法好坏的重要手段； ●时间复杂度：以算法执行时间长短来衡量 ●空间复杂度：以算法执行占用的存储空间来衡量
第二章算法 第三章设计模式 3.1面向对象设计原则 单一职责原则：要求每个对象应该只有一种责任； 开闭原则：设计程序时对扩展开放，对修改关闭； 里氏替换原则：任何情况下，子类替换父类，不会影响程序运行； 依赖倒置原则：提倡高层不依赖底层，二者都依赖抽象； 接口隔离原则：把多个功能分开声明，不强迫客户实现不需要的功能； 迪米特原则：最少只是原则尽可能的降低访问级别； 组合/聚合复用原则：尽量不用继承达到复用类的目的，而是使用组合和聚合。 3.2设计模式分类 创建型模式：如何创建对象以及何时创建对象，工厂模式，单例模式 结构型模式：对象该如何组织以及采用什么样的结构更合理 行为型模式：规定了各个对象应该具备的职责以及对象间的通信模式 3.3什么是框架 应用程序骨架；框架技术的优势在于： ●不用再考虑公共问题，框架已经帮我们做好了 ●可以专心在业务逻辑上，保证核心业务逻辑的开发质量 ●结构统一，便于学习、维护 ●框架集成的前人的经验有助于写出稳健、性能优良并且结构优良的高质量程序 3.4主流框架 3.4.1 Struts框架 最早的Java开源框架之一，定义了通用的Controller(控制器)，通过配置文件（一般是struts-config.xml）隔离了Model(模型)和View(视图)，以Action的概念对用户请求进行了封装，是代码更清晰易读。 3.4.2 Struts2框架 新的框架特性： ●从逻辑中分离出横切关注点的拦截器 ●减少或者消除配置文件 ●贯穿整个框架的强大表达式语言 ●支持可变更和可重用的基于MVC模式的标签API
java_Set,List,Map,Vector,ArrayList的区别
JAVA的容器---List,Map,Set Collection ├List │├LinkedList │├ArrayList │└Vector │└Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection接口 Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。 如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下： Iterator it = collection.iterator(); // 获得一个迭代子 while(it.hasNext()) { Object obj = it.next(); // 得到下一个元素 } 由Collection接口派生的两个接口是List和Set。
java开发技术总结
数据库 oracle-->数据库管理系统-->SQL、PL/SQL-->Java(JDBC+SQL) DBA,数据库编程程序员 1.概念导论 1）什么是数据库 有组织和结构存储数据。可以存储 字符、字节、图形、图像等类型数据 DB(数据库):数据集合 DBMS(数据库管理系统)：对数据集合进行管理和操作的软件 --Oracle --DB2 --MySQL --SQLSERVER JDBC 1.什么是JDBC 全称Java DataBase Connection,Java数据库访问。 JDBC是Java访问数据库的一项技术 JDBC是SUN推出的Java访问数据库的一套标准。由一系列接口构成。 各个数据库厂商负责提供JDBC接口API的实现包。 开发者只需要掌握JDBC接口的使用,就可以实现对各种数据库的操作，不需要了解开发商的实现类。 XML 1、什么是xml(xtendsible markup language可扩 展的标记语言)? 1)定义 基于文本的通用的数据保存格式。 (1)通用的点的坐标 Point类point对象(x=10,y=20) a,序列化 b,数据库表 c,文件 ... (2)数据格式
HTML 知识准备 1、分层：表现层：UI界面（DOS界面、桌面类型、web类型） 业务层： 数据层：文件、Oracle数据库 2、Web类型的应用程序----B/S类型 打开Browser，输入URL，浏览器将请求发送到服务器 服务器得到请求，分析，返回响应 浏览器得到响应，解析（翻译），显示为页面 3、web学习阶段 客户端技术：HTML+CSS+Javascript---Web基础 服务器端技术：JSP、PHP、https://www.360docs.net/doc/7916360298.html, 4、web基础的课程 HTML：页面的创建 CSS：页面的外观 JavaScript：页面的动态效果和交互行为--3 一：HTML概述 1、超文本标记语言：一种编写页面的纯文本的标记语言，文件以.html或者.htm为后缀，依靠浏览器运行显示----解释性的语言 2、标记：一些用<>括起来的内容，特殊的显示 3、主流浏览器：IE/Firefox/Chrome/ 4、浏览器兼容性：符合标准规范，具体问题 CSS 一：CSS概述 1、CSS：级联样式表（层叠样式表） 2、特征：为页面定义外观的语言，实现内容和表现的分离，多个样式可以合为一个，如果冲突，以优先级为准 二：基础语法 1、语法：属性名称:值;属性名称:值;比如--color:red; 2、如何应用 方式一（内联方式）：<元素style=""/>---将样式直接定义在元素的style属性里 方式二（内部样式表）：在页面的head里的style里定义样式 方式三（外部样式表）：定义一个单独的.css的文件（定义样式）；然后，在页面的head里用link引入---推荐方式 3、外部样式表的优点：实现内容和表现的分离，提高代码的可重用性和可维护性
慕课网分享：40个Java集合面试问题和答案
慕课网分享：40个Java集合面试问题和答案 Java集合框架为Java编程语言的基础，也是Java面试中很重要的一个知识点。这里，慕课网列出了一些关于Java集合的重要问题和答案，程序员们，你能回答出几道问题呢？ 1.Java集合框架是什么?说出一些集合框架的优点? 每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。集合框架的部分优点如下： (1)使用核心集合类降低开发成本，而非实现我们自己的集合类。 (2)随着使用经过严格测试的集合框架类，代码质量会得到提高。 (3)通过使用JDK附带的集合类，可以降低代码维护成本。 (4)复用性和可操作性。 2.集合框架中的泛型有什么优点? Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。 3.Java集合框架的基础接口有哪些?
Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。 List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。 Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。 一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。 4.为何Collection不从Cloneable和Serializable接口继承? Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。 当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。 在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。 5.为何Map接口不继承Collection接口? 尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。 如果Map继承Collection接口，那么元素去哪儿?Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。 6.Iterator是什么? Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。 7.Enumeration和Iterator接口的区别? Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。 迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。
JAVA 框架 SPRING 总结
Spring是什么？ Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。他提供依赖注入容器，目标是使现有的技术更加易用，促进良好的编程习惯。 Spring框架是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean的方式 Spring的6大容器 1、核心容器：核心容器提供Spring框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 2、Spring（JEE）上下文：Spring上下文是一个配置文件，向Spring框架提供上下 文信息。Spring上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化、校验和调度功能。 3、Spring AOP：通过配置管理特性，Spring AOP模块直接将面向方面的编程功能集 成到了Spring框架中。所以，可以很容易地使Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖EJB组件，就可以将声明性事务管理集成到应用程序中。 4、Spring DAO：JDBC DAO抽象层提供了有意义的异常层次结构，可用该结构来管 理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层次结构。 5、Spring ORM：Spring框架插入了若干个ORM框架，从而提供了ORM的对象关 系工具，其中包括JDO、Hibernate和iBatis SQL Map。所有这些都遵从Spring的通用事务和DAO异常层次结构。 6、Spring Web模块：Web上下文模块建立在应用程序上下文模块之上，为基于Web 的应用程序提供了上下文。所以，Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。 7、Spring MVC框架：MVC框架是一个全功能的构建Web应用程序的MVC实现。 通过策略接口，MVC框架变成为高度可配置的，MVC容纳了大量视图技术，其中包括JSP、Velocity、Tiles、iText和POI。 Spring框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring的核心要点是：支持不绑定到特定J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。
java中List的用法
java中List的用法和实例详解 List的用法 List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列表类型，所以List接口还提供了一些适合于自身的常用方法，如表1所示。 表1 List接口定义的常用方法及功能 从表1可以看出，List接口提供的适合于自身的常用方法均与索引有关，这是因为List集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。 List接口的常用实现类有ArrayList和LinkedList，在使用List集合时，通常情况下声明为List类型，实例化时根据实际情况的需要，实例化为ArrayList或LinkedList，例如： List
java基础总结
第一章初识java 一、java语言的历史 ●第一代java语言：Oak 二、java语言的现状 ?Java SE:主要用于桌面程序的开发。 ?Java EE:主要用于网页程序的开发。 ?Java ME:主要用于嵌入式系统程序的开发。（安卓）三、java语言的特点 ●跨平台（不同的操作系统都可运行） ●简单（没有直接使用指针） ●面向对象（世间万物皆为对象） ●半编译半解释（java文件---class文件----虚拟机） ●分布式（多个客户端访问、通过服务器的配置分发到 不同的服务器） ●健壮（异常的处理） ●安全（任何语言都具备、虚拟机沙箱原理） ●多线程、高性能、动态 四、java语言与C、C++语言的不同与区别 ●自动内存管理：Java对于内存的分配是动态的，并具 有垃圾回收机制。 ●不在类外定义全局变量。 ●Java中将不再使用goto语句。
●Java中取消了指针。 ●运行时系统对类型转换进行类型相容性检查 ●Java不支持头文件，使用import与其它类通讯。 ●Java中不包含结构和联合；所有的内容都封装在类中。 ●Java中不支持宏，它通过final 关键字来声明一个常 量。 ●Java不支持多重继承，可以通过Java中的接口实现 多重继承的功能。 ●CC++ 一般情况下都是偏硬件的，java一般偏软件（应 用、基于浏览器） ●（补充）.net、php （网页制作比较快捷）、在安全级 别要求高的企业一般使用java（银行、政府系统） 五、环境的搭建 1、默认路径如下 ●C:\Program Files\Java\jdk1.6.0_02：提供编程中需要 的api包 ●C:\Program Files\Java\jre1.6.0_02：虚拟机文件所在的 位置 2.安装后各个文件夹代表的含义
Java框架面试题总结
目录 ................................................................................................................ Struts 篇4 1. Struts的工作流程 (4) 2. Struts的工作流程分解 (4) 3. Struts控制器组件的组成. 和控制器的主要功能 (4) 4. Struts中的几个关键对象的作用(说说几个关键对象的作用) (4) 5. Struts工作流程图(用例图) (5) 6. 说说MVC设计模式和它的优点 (5) 7. 说说struts是如何实现MVC的? (6) 8. Struts优点与缺点 (6) 9 . strust的Action是不是线程安全的？如果不是有什么方式可以保证Action的线程安 (6) 10. Tiles框架是什么？ (6) 11. struts1.x 和struts 2 的区别 (6) 12 . Struts 的常用标签库及用法 (8) Struts html标签库 (8) Struts bean标签库 (12) Struts Logic标签库 (13) 13、JSP中动态INCLUDE与静态INCLUDE的区别？ (15)
15 1. ............................................................................................................. a jax是什么15 2. .................................................................................................... ajax实现的原理16 3. ............................................................................................. ajax框架的基本流程16 4. .................................................................................................... dwr的实现原理. 16 5. ...................................................................................................... ajax 开发步骤. 16 ............................................................................................................... Spring 篇16 一. .............................................................................................................. 基础知识16 1. ........................................................................................................ 对IOC的理解. 16 2. ..................................................................................... 依赖注入的三种实现形式? 17 3. ............................................................................ Setter注入和构造方法注入比较18 4. ............................................... 对AOP的理解,以及AOP在项目中是如何使用的? 18
java集合类总结
1.本讲内容：集合collection （数组和集合90%功能相似，但是最大的区别是，数组在初始化的时候必须确定大小，而集合不用，而且集合是一堆的类，使用起来非常方便。） 讲集合collection之前，我们先分清三个概念： 1colection 集合，可用来存储任何对象的一种数据结构（容器）。 2Collection 集合接口，指的是，是Set、List 和Queue 接口的超类接口 3Collections 集合工具类，指的是类。 SCJP考试要求了解的接口有：Collection , Set , SortedSet , List , Map , SortedMap , Queue , NavigableSet , NavigableMap, 还有一个Iterator 接口也是必须了解的。 SCJP考试要求了解的类有：HashMap , Hashtable ,TreeMap , LinkedHashMap , HashSet , LinkedHashSet ,TreeSet , ArrayList , Vector , LinkedList , PriorityQueuee , Collections , Arrays 下面给出一个集合之间的关系图： 上图中加粗线的ArrayList 和HashMap 是我们重点讲解的对象。下面这张图看起来层级结构更清晰些。 我们这里说的集合指的是小写的collection，集合有4种基本形式，其中前三种的父接口是Collection。 4List 关注事物的索引列表 5Set 关注事物的唯一性 6Queue 关注事物被处理时的顺序 7Map 关注事物的映射和键值的唯一性 一、Collection 接口 Collection接口是Set 、List 和Queue 接口的父接口，提供了多数集合常用的方法声明，包括add()、remove()、contains() 、size() 、iterator() 等。 add(E e) 将指定对象添加到集合中 remove(Object o) 将指定的对象从集合中移除，移除成功返回true,不成功返回false contains(Object o) 查看该集合中是否包含指定的对象，包含返回true,不包含返回flase size() 返回集合中存放的对象的个数。返回值为int clear() 移除该集合中的所有对象，清空该集合。 iterator() 返回一个包含所有对象的iterator对象，用来循环遍历 toArray() 返回一个包含所有对象的数组,类型是Object toArray(T[] t) 返回一个包含所有对象的指定类型的数组 我们在这里只举一个把集合转成数组的例子，因为Collection本身是个接口所以，我们用它的实现类ArrayList做这个例子：例子1： package edu.xjfu;
Java集合框架的知识总结
Java集合框架的知识总结 说明：先从整体介绍了Java集合框架包含的接口和类，然后总结了集合框架中的一些基本知识和关键点，并结合实例进行简单分析。 1、综述 所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。 当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。 Java的集合类主要由两个接口派生而出：Collection和Map，Col lection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。
Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。 Map实现类用于保存具有映射关系的数据（key-value）。 Set、List和Map可以看做集合的三大类。 List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。 Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。 Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的k ey来访问其value。 对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayLi st和HashMap三个实现类。（并发控制的集合类，以后有空研究下）。2、Collection接口 Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。Collection接口定义操作集合元素的具体方法大家可以参考API文档，这里通过一个例子来说明Collection的添加元素、删除元素、返回集合中元素的个数以及清空集合元素的方法。 public class TestCollection {
Java Map集合
java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和V ector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。从概念上而言，您可以将List 看作是具有数值键的Map。而实际上，除了List 和Map 都在定义java.util 中外，两者并没有直接的联系。本文将着重介绍核心Java 发行套件中附带的Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用Map。 了解Map 接口和方法 Java 核心类中有很多预定义的Map 类。在介绍具体实现之前，我们先介绍一下Map 接口本身，以便了解所有实现的共同点。Map 接口定义了四种类型的方法，每个Map 都包含这些方法。下面，我们从两个普通的方法（表1）开始对这些方法加以介绍。 表1：覆盖的方法。我们将这Object 的这两个方法覆盖，以正确比较Map 对象的等价性。 Map 构建 Map 定义了几个用于插入和删除元素的变换方法（表2）。 表2：Map 更新方法：可以更改Map 内容。 尽管您可能注意到，纵然假设忽略构建一个需要传递给putAll() 的Map 的开销，使用putAll() 通常也并不比使用大量的put() 调用更有效率，但putAll() 的存在一点也不稀奇。这是因为，putAll() 除了迭代put() 所执行的将每个键值对添加到Map 的算法以外，还需要迭代所传递的Map 的元素。但应注意，putAll() 在添加所有元素之前可以正确调整Map 的大小，因此如果您未亲自调整Map 的大小（我们将对此进行简单介绍），则putAll() 可能比预期的更有效。 查看Map 迭代Map 中的元素不存在直接了当的方法。如果要查询某个Map 以了解其哪些元素满足特定查询，或如果要迭代其所有元素（无论原因如何），则您首先需要获取该Map 的“视图”。有三种可能的视图（参见表3） 所有键值对—参见entrySet() 所有键—参见keySet() 所有值—参见values() 前两个视图均返回Set 对象，第三个视图返回Collection 对象。就这两种情况而言，问题到这里并没有结束，这是因为您无法直接迭代Collection 对象或Set 对象。要进行迭代，
Java中集合类用法总结
帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记，添加批注？ Java 中集合?用法总结（转载） wade0564 收录于2010-07-08 阅读数：查看 收藏数：7 公众公开 原文来源 tags ： java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章，想收藏这篇好文章吗，赶快 吧，1分钟拥有自己的个人图书馆！ 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList （异步，线程不安全，空间用完时自动增长原容量一半）│└Vector （同 步，线程安全，空间用完时自动增长原容量一倍）│ └Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口： | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中，当某个键不再正常使用时，将自动移除其条 | 目。更精确地说，对于一个给定的键，其映射的存在并不阻止垃圾回收器对该键的丢弃，这就使该键成为 可终止的，被终 | 止，然后被回收。丢弃某个键时， 其条目从映射中有效地移除，因此，该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序，或?根据创建映射时提供的 Comparator 进行 排序，具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了 | 非同步和允许 使用 null 之外，HashMap 类与 Hashtable ?致相同。）此类不保证映射的顺序，特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的，或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图（由 entrySet 、keySet 和 values 方法返回 ）进行迭代时，此顺序就会反映 出来。要采用此排序方式，还需要提供一些其他操作（此接?是 SortedSet 的对应映 射）。 Collection 接口： | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味，有多少男人可以读懂？珍稀的白头叶猴（组图）三鹿门事件之——中国，...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品：守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语，十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事