package zz2Map;
/*
* 关于Map集合中常用的方法
*
* void clear(); 清空Map
* boolean isEmpty(); 判断该集合是否为空
* int size(); 获取Map中键值对的个数
*
* Object put(Object key, Object value); 向集合中添加键值对
* Object get(Object key); 通过key获取value
*
* boolean containsKey(Object key); 判断Map中是否包含这样的key
* boolean containsValue(object value); 判断Map中是否包含这样的value
*
* Object remove(Object key); 通过key将键值对删除
*
* Collection values(); 获取Map集合中所有的value
*
* Set keySet(); 获取Map中所有的key
*
* Set entrySet(); 返回此映射中包含的映射关系的set视图
*
* 注意：存储在Map集合key部分的元素需要同时重写hashCode + equals方法
*/
import java.util.*;
public class MapTest01 {
public static void main(String[] args) {
//1.创建Map集合
Map persons = new HashMap(); //HashMap的默认初始化容量是16，默认加载因子0.75
//2.存储键值对
persons.put("10000", "JACK");
persons.put("10011", "JACK");
persons.put("10002", "SUN");
persons.put("10003", "KING");
persons.put("10000", "LUCK");
//3.判断键值对的个数
//Map中的key是无序不可重复的，和HashSet相同
System.out.println(persons.size()); //4
//4.判断集合中是否包含这样的key
System.out.println(persons.containsKey("10000")); //true
//5.判断集合中是否包含这样的value
//注意：Map中如果key重复，value采用的是覆盖
System.out.println(persons.containsValue("LUCK")); //true
//6.通过key获取value
String k = "10011";
Object v = persons.get(k);
System.out.println(v); //JACK
//7.通过key删除键值对
persons.remove("10002");
System.out.println(persons.size()); //3
//8.获取所以的value
Collection values = persons.values();
Iterator it = values.iterator();
while(it.hasNext()){
System.out.println(it.next()); //LUCK JACK KING
}
//9.获取所有的key
//以上程序掩饰如何遍历Map集合
Set keys = persons.keySet();
Iterator it2 = keys.iterator();
while(it2.hasNext()){
Object id = it2.next();
Object name = persons.get(k);
System.out.println(id+"-->"+name); //10000-->JACK 10011-->JACK 10003-->JACK
}
//10.entrySet
//将Map转换成Set集合，不过用的不多
/*
Set entrySet = persons.entrySet();
Iterator it3 = entrySet.iterator();
while(it3.hasNext()){
System.out.println(it3.next()); //10000=LUCK 10011=JACK 10003=KING
}
*/
}
}
package zz2Map;
/*
* HashMap默认初始化容量是16，默认加载因子0.75
* Hashtable默认初始化容量是11，默认加载因子是0.75
*
* java.util.Properties; 也是由key和value组成，但是key和value都是字符串类型
*/
import java.util.Properties;
public class MapTest02 {
public static void main(String[] args) {
//1.创建属性类对象
Properties p = new Properties();
//2.存
//注意key不能重复，否则value覆盖
p.setProperty("driver", "oracle.jdbc.driver.OracleDriver");
p.setProperty("username", "scott");
p.setProperty("password", "tiger");
p.setProperty("url", "jdbc:oracle:thin:@192.168.1.100:1525:bjpowernode");
//3.取，通过key获取value
String v1 = p.getProperty("driver");
String v2 = p.getProperty("username");
String v3 = p.getProperty("password");
String v4 = p.getProperty("url");
System.out.println(v1);
System.out.println(v2);
System.out.println(v3);
System.out.println(v4);
}
}
package zz2Map;
import java.util.*;
/*
* SortedMap中的key特点：无序不可重复，但是存进去的元素可以按照大小自动排列
*
* 如果想自动排序：key部分的元素需要：1.实现Comparable接口 2.单独写一个比较器
*/
public class SortedMapTest01 {
public static void main(String[] args) {
//Map，key存储Product，value存储个数
SortedMap products = new TreeMap();
//准备对象
Product p1 = new Product("西瓜", 1.0);
Product p2 = new Product("苹果", 4.0);
Product p3 = new Product("桃子", 5.0);
Product p4 = new Product("香蕉", 3.0);
//添加
products.put(p1, 8.0);
products.put(p2, 3.0);
products.put(p3, 4.0);
products.put(p4, 10.0);
//遍历
Set keys = products.keySet();
Iterator it = keys.iterator();
while(it.hasNext()){
Object k = it.next();
Object v = products.get(k);
System.out.println(k+"-->" + v +"kg");
}
}
}
//实现Comparable接口
class Product implements Comparable{
String name;
double price;
Product(String name, double price){
this.name = name;
this.price = price;
}
public String toString(){
return "Product[name="+name+",price="+price+"]";
}
//实现compareTo方法
//需求：按照商品价格排序
public int compareTo(Object o){
double price1 = this.price;
double price2 = ((Product)o).price;
if(price < price2){
return -1;
}else if(price1 > price2){
return 1;
}else{
return 0;
}
}
}
package zz2Map;
/*
* 关于集合工具类 java.util.Collections; 类
*
* java.util.Collection;集合接口.
*/
import java.util.*;
public class CollectionsTest01 {
public static void main(String[] args) {
//使用Collections工具完成集合的排序
List l = new ArrayList();
//添加元素
l.add(10);
l.add(5);
l.add(9);
l.add(20);
l.add(1);
//遍历
//方法1
/*
for(int i=0; i<l.size(); i++){
System.out.println(l.get(i));
}
*/
//方法2
/*
for(Iterator it = l.iterator(); it.hasNext();){
System.out.println(it.next());
}
*/
//方法3
Iterator it = l.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//10 5 9 20 1
//排序
Collections.sort(l);
System.out.println("=======");
//遍历
it = l.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//1 5 9 10 20
//给定Set集合
Set s = new HashSet();
s.add(1);
s.add(10);
s.add(9);
s.add(8);
s.add(7);
//对Set集合排序
//将Set集合转换成List集合
List listS = new ArrayList(s);
Collections.sort(listS);
System.out.println("=======");
//遍历
for(int i=0; i<listS.size(); i++){
System.out.println(listS.get(i));
}
//创建List集合，List集合中存储Person类型，是否可以排序？
/*
//Collections工具类可以对List集合中的元素排序，但是集合中的元素必须是“可比较的”，实现Comparable接口
List ps = new ArrayList();
ps.add(new Person());
ps.add(new Person());
ps.add(new Person());
Collections.sort(ps);
*/
//将ArrayList集合转换成线程安全的
List myList = new ArrayList();
Collections.synchronizedList(myList);
}
}
class Person{}
package zz2Map;
/*
* JDK5.0新特性
* 关于增强for循环
*
* 语法：
* for(类型 变量:数组名/集合名){}
*
* 集合想要使用增强for循环这种语法，集合需要使用泛型
* 如果不使用泛型，需要用 Object类型来定义集合中的元素。
*/
import java.util.*;
public class ForeachTest01 {
public static void main(String[] args) {
int[] a = {1, 2, 34, 5, 6, 7};
//遍历
for(int i = 0; i<a.length; i++){
System.out.println(a[i]);
}
System.out.println("========");
//Foreach
for(int e:a){ //int e代表的是集合或者数组中的每个元素
System.out.println(e);
}
//集合
Set<String> strs = new HashSet<String>();
strs.add("张三");
strs.add("李四");
strs.add("王五");
strs.add("赵六");
//遍历
for(String name:strs){
System.out.println(name);
}
//集合不使用泛型
List l = new ArrayList();
l.add(1);
l.add(2);
l.add(3);
//如果集合不使用泛型
//该集合在用增强for循环的时候应该用Object类型定义，不用Iterator
for(Object element:l){
System.out.println(element);
}
}
}
package zz2Map;
/*
* 关于JDK5.0新特性：泛型（编译期概念）
*
* 1.为什么引入泛型？
* 1.可以统一集合中的数据类型
* 2.可以减少强制类型转换
*
* 2.泛型语法如何实现？
*
* 3.泛型的优点和缺点？
* 优点：统一类型，减少强制转换
* 缺点：只能存储一种类型。
*
* 以下程序没有使用泛型，缺点？
* 如果集合不使用泛型，则集合中的元素类型不统一
* 在遍历集合的时候，只能拿出来Object类型，需要
* 做大量的强制类型转换。麻烦
*/
import java.util.*;
public class GenericTest01 {
public static void main(String[] args) {
//创建一个集合，存储A，B，C
Set s = new HashSet();
//创建对象
A a = new A();
B b = new B();
C c = new C();
s.add(a);
s.add(b);
s.add(c);
//需求：遍历集合，如果是A类型调用m1方法，B类型调用m2方法，C类型调用m3方法
Iterator it = s.iterator();
while(it.hasNext()){
Object o = it.next();
//只能做大量的强制类型转换
if(o instanceof A){
A a1 = (A)o;
a.m1();
}else if(o instanceof B){
B b1 = (B)o;
b.m2();
}else if(o instanceof C){
C c1 = (C)o;
c.m3();
}
}
}
}
class A{
public void m1(){
System.out.println("A's m1...");
}
}
class B{
public void m2(){
System.out.println("B's m2...");
}
}
class C{
public void m3(){
System.out.println("C's m3...");
}
}
package zz2Map;
/*
* 2.泛型语法如何实现？
* 泛型是一个编译阶段的语法
在编译阶段统一集合中的类型
*/
import java.util.*;
public class GenericTest02 {
public static void main(String[] args) {
//创建一个List集合，只能存储字符串类型
List<String> strs = new ArrayList<String>();
//添加元素
strs.add("JACK");
strs.add("SUN");
strs.add("KING");
strs.add("SMITH");
//遍历
Iterator<String> it = strs.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
/*
* JACK
* SUN
* KING
* SMITH
*/
}
}
}
package zz2Map;
/*
* Map使用泛型
*/
import java.util.*;
public class GenericTest03 {
public static void main(String[] args) {
Map<String,Integer> maps = new HashMap<String,Integer>();
//存
maps.put("西瓜", 10);
maps.put("苹果", 12);
maps.put("香蕉", 19);
//遍历
Set<String> keys = maps.keySet();
Iterator<String> it = keys.iterator();
while(it.hasNext()){
String k = it.next();
Integer v = maps.get(k);
System.out.println(k + "--->" + v);
/*
* 香蕉--->19
* 西瓜--->10
* 苹果--->12
*/
}
}
}
package zz2Map;
/*
* 关于增强for的缺点：没有下标
*/
public class ForeachTest02 {
public static void main(String[] args) {
String[] ins = {"运动","音乐","旅游","美食"};
StringBuffer sb = new StringBuffer();
for(int i=0; i<ins.length; i++){
if(i == ins.length - 1){
sb.append(ins[i]);
}else{
sb.append(ins[i]);
sb.append(",");
}
}
System.out.println(sb); //运动,音乐,旅游,美食
//以上的循环就不适用增强for
for(String s:ins){
sb.append(s);
sb.append(",");
//运动,音乐,旅游,美食,
}
//截取掉后面的,号
System.out.println(sb.substring(0, sb.length()-1)); //运动,音乐,旅游,美食
}
}
package zz2Map;
/*
* SortedSet集合使用泛型
*/
import java.util.*;
public class GenericTest04 {
public static void main(String[] args) {
SortedSet<Manager> ss = new TreeSet<Manager>();
//添加
Manager m1 = new Manager(1000.0);
Manager m2 = new Manager(1300.0);
Manager m3 = new Manager(1500.0);
ss.add(m1);
ss.add(m2);
ss.add(m3);
//遍历
Iterator<Manager> it = ss.iterator();
while(it.hasNext()){
Manager m = it.next();
m.work();
}
}
}
class Manager implements Comparable<Manager>{
double sal;
Manager(double sal){
this.sal = sal;
}
public String toString(){
return sal + "";
}
public void work(){
System.out.println("工作，一个月"+sal+"元");
}
//实现接口中的方法
public int compareTo(Manager m){
double sal1 = this.sal;
double sal2 = m.sal; //不需要强转
if(sal1 > sal2){
return 1;
}else if(sal1 < sal2){
return -1;
}
return 0;
}
}
package zz2Map;
/*
* 自定义泛型
*/
public class GenericTest05 {
public static void main(String[] args) {
MyClass<String> m0 = new MyClass<String>();
//泛型就是编译期检查类型
//Error
//m0.m1(100); 要字符串类型的
m0.m1("JACK");
}
}
//自定义泛型
class MyClass<T>{ //T可以随便编写，但最好不是T就是E
public void m1(T t){
System.out.println(t); //JACK
}
}
浙公网安备 33010602011771号