21Map_System类
导语：
日后可总结：
Map常见功能。
1. 存储。v put(k,v);
2. 获取。v get(k);
3. 移除。v remove(k);
4. Set<k> keySet();
5. Set<Map.Entry<k,v>> entrySet();
6. Collection<v> values();
Map
|--Hashtable：数据结构：哈希表。是同步的，不允许null作为键和值。被hashMap替代。
|--Properties：属性集，键和值都是字符串，而且可以结合流进行键值的操作。等到了IO流，你会更清楚。
|--HashMap：数据结构：哈希表。不是同步的，允许null作为键和值。
|--LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。
|--TreeMap：数据结构：二叉树。不是同步的。可以对map集合中的键进行排序。
- MapDemo
- MapDemo2
- HashMapTest
- TreeMapTest
- ComparatorByName
- MapTest
- ParamDemo
- StaticImportDemo
- MathDemo
- SystemDemo
- Student
MapDemo
package cn.itcast.api.a.map;
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
/**
* @param args
*/
public static void main(String[] args) {
/*
* 存储中英文星期。
* 使用map集合。
*/
Map<String,String> map = new HashMap<String,String>();
//添加元素。
System.out.println(map.put("星期一", "Monday"));
// System.out.println(map.put("星期一", "Mon"));//如果键相同，值覆盖。并put方法会返回旧值。如果没有旧值就null。
//....
map.put("星期日", "Sunday");
//通过给定键获取值。
String value = map.get("星期二");//如果键 不存在，返回null，通过此判断键的是否存在。
System.out.println("value="+value);
//删除元素。根据键删除。
String s = map.remove("星期一");//获取给定键对应的值，并将该键值对从map集合删除。
System.out.println("s="+s);
System.out.println(map);
}
}
MapDemo2
package cn.itcast.api.a.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("星期一", "Monday");
map.put("星期日", "Sunday");
System.out.println("------------keySet方法的获取---------------");
// System.out.println(map.get("星期一"));
//怎么获取到所有的键呢？既然是所有的键，应该是一个集合，而且是一个单列集合。
//list还是set呢？应该是set，因为map集合中键需要保证唯一性。
//找到一个方法 Set<k> keySet();获取map集合中的键的set集合。
Set<String> keySet = map.keySet();
for(Iterator<String> it= keySet.iterator(); it.hasNext() ; ){
String key = it.next();
String value = map.get(key);//通过键获取对应的值。
System.out.println(key+"::"+value);
}
//使用foreach循环，进行遍历。
for(String key : keySet){
System.out.println(key+":::::"+map.get(key));
}
System.out.println("-----------entrySet方法获取----------------");
/*
* Set entrySet():将map集合中映射关系存储到了Set集合中.
* 映射关系：其实就是指键和值的对应关系。其实就是夫妻的结婚证。
* 映射关系是什么类型的呢？ Map.Entry
*/
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
//遍历Set中的映射关系对象。
while(it.hasNext()){
Map.Entry<String, String> me = it.next();//取到了映射关系对象。
//获取键。
String key = me.getKey();
//获取值。
String value = me.getValue();
System.out.println(key+"-----"+value);
}
/*
* 总结：map集合没有迭代器，取出元素的方式：将map集合转成单列结合，在使用单列集合的迭代器就可以了。
* map集合也不能直接被foreach循环遍历。
*/
for(Map.Entry<String,String> me : map.entrySet()){
String key = me.getKey();
//获取值。
String value = me.getValue();
System.out.println(key+"--------"+value);
}
System.out.println("-----------获取所有值的方法 values()----------------");
/*
* 获取所有的值，因为值不需要保证唯一性。所以返回类型时Collection。
* 姓名--归属地。对应关系，获取所有的归属地。values();
*/
//所有的英文星期。
Collection<String> values = map.values();
for(String value : values){
System.out.println("value:"+value);
}
}
}
//interface MyMap{
// public static interface MyEntry{}//内部接口。
//}
HashMapTest
package cn.itcast.api.b.map.subclass;
import java.util.HashMap;
import java.util.Map;
import cn.itcast.domain.Student;
public class HashMapTest {
/**
* @param args
*/
public static void main(String[] args) {
/*
* 练习一：
* 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。
* 将学生对象和归属地存储到map集合中。
* 注意：同姓名同年龄视为重复的键。
*/
//1,创建hashmap集合对象。
Map<Student,String> map = new HashMap<Student,String>();
//2,添加元素。
map.put(new Student("lisi",28), "上海");
map.put(new Student("wangwu",22), "北京");
map.put(new Student("zhaoliu",24), "成都");
map.put(new Student("zhouqi",25), "广州");
map.put(new Student("wangwu",22), "南京");
//3,取出元素。keySet entrySet
// Set<Student> keySet = map.keySet();
// for(Student key : keySet){}
for(Student key : map.keySet()){
String value = map.get(key);
System.out.println(key.toString()+"....."+value);
}
}
}
TreeMapTest
package cn.itcast.api.b.map.subclass;
import java.util.Map;
import java.util.TreeMap;
import cn.itcast.api.c.comparator.ComparatorByName;
import cn.itcast.domain.Student;
public class TreeMapTest {
/**
* @param args
*/
public static void main(String[] args) {
/*
* 练习二： 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。 将学生对象和归属地存储到map集合中。
* 注意：同姓名同年龄视为重复的键。 按照学生的年龄进行从小到大的排序。 TreeMap。
*
* 如果要对学生按照姓名排序呢？
*/
// 1,创建TreeMap集合对象。
Map<Student, String> map = new TreeMap<Student, String>(new ComparatorByName());
// 2,添加元素。
map.put(new Student("lisi", 28), "上海");
map.put(new Student("wangwu", 22), "北京");
map.put(new Student("zhaoliu", 24), "成都");
map.put(new Student("zhouqi", 25), "广州");
map.put(new Student("wangwu", 22), "南京");
//3,取出所有元素，entrySet()
for(Map.Entry<Student, String> me : map.entrySet()){
Student key = me.getKey();
String value = me.getValue();
System.out.println(key+"::"+value);
}
}
}
ComparatorByName
package cn.itcast.api.c.comparator;
import java.util.Comparator;
import cn.itcast.domain.Student;
public class ComparatorByName implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0?o1.getAge() - o2.getAge() : temp;
}
}
MapTest
package cn.itcast.api.d.test;
import java.util.Map;
import java.util.TreeMap;
public class MapTest {
/**
* @param args
*/
public static void main(String[] args) {
/*
* 练习：
* "werertrtyuifgkiryuiop",获取字符串中每一个字母出现的次数。
* 要求返回结果个格式是 a(1)b(2)d(4)......;
* 思路：
* 1，获取到字符串中的每一个字母。
* 2，用字母取查表，如果查到了该字母对应的次数，就将这个次数+1后重新存回表中。
* 如果没有查到呢？将该字母和1存到表中。
* 3，每一字母都查完表后，表中记录的就是所有字母出现的次数。
*
* 字母和次数之间存在对应关系，而且字母是唯一性的，所以可以使用map集合做表进行查询。
* 通过结果发现 字母有顺序的，所以可以通过map集合中的treemap作为表。
*
*/
String str = "awaa+acr=ebarct,btydui[efgkiryuiop";
str = getCharCount(str);
System.out.println(str);
}
/**
* 获取字符串中的字母出现次数。
*
* @param str
* @return 返回一个每一个字母对应次数的字符串 格式 char1(count)char2(count).....;
*/
public static String getCharCount(String str) {
//1，将字符串转成字符数组。
char[] chs = str.toCharArray();
//2，定义表。treemap.
TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();
//3，遍历字符数组。
for (int i = 0; i < chs.length; i++) {
//判断必须是字母。
if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z')){
continue;
}
//4，将遍历到的字母作为键去查map这个表。获取对应的次数。
Integer value = map.get(chs[i]);
//5，有可能要查询的字母在表中不存在对应的次数，需要判断。
//如果返回是null，说明字母没有对应的次数。就将这个字母和1存储到表中。
if(value == null){
//将字母和1存储。
map.put(chs[i],1);
}else{
//否则，说明有对应的次数对次数自增。将字母和新的次数存储到表中。
value++;
map.put(chs[i],value);
}
/*
//两个if判断，选择哪个都行。
int count = 0;
if(value!=null){
count = value;//用count记录次数。
}
count++;//自增。
map.put(chs[i], count);
*/
}
//将map集合中的键值转成 格式是 a(1)b(2)d(4)......
return mapToString(map);
}
/*
* 将map集合中的键值转成 格式是 a(1)b(2)d(4)......
* map中有很多数据，无论是多少个，什么类型，最终都变成字符串。
* StringBuffer 这个容器就符合这个需求。如果是单线程，建议使用StringBuilder。
*
*/
private static String mapToString(Map<Character, Integer> map) {
//1，明确容器。
StringBuilder sb = new StringBuilder();
//2,遍历map集合。
for(Character key : map.keySet()){
Integer value = map.get(key);
sb.append(key+"("+value+")");
}
return sb.toString();
}
}
ParamDemo
package cn.itcast.api.e.jdk5;
public class ParamDemo {
/**
* @param args
*/
public static void main(String[] args) {
// int[] arr = {34,12,89};
// int sum = add(arr);
// System.out.println("sum="+sum);
// int[] arr1 = {23,11,44,55,66};//先创建数组，再将这个数组作为实参传递给add方法。
// int sum1 = add(arr1);
// System.out.println("sum1="+sum1);
//jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。
//同样是代表数组，但是在调用这个带有可变参数的函数时，不用创建数组(这就是简单之处)，直接
//将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些实参先封装到一个数组中，在进行传递。
//这些动作编译器在生产class时，都帮你完成了。
int sum = add(34,12,89);
System.out.println("sum="+sum);
int sum1 = add(23,11,44,55,66);
System.out.println("sum1="+sum1);
//注意事项：记录可变参数一定要定义在参数列表最后。
//public static int add(int a,int... arr)
}
public static int add(int... arr){// 数组参数的简化表现形式。 ... 代表很多int类型数据。
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
/*
// 求多个整数的和。
public static int add(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
*/
// 求两个整数的和。
public static int add(int a, int b) {
return a + b;
}
// 求三个整数的和。
public static int add(int a,int b,int c){
return a + b + c;
}
}
StaticImportDemo
package cn.itcast.api.e.jdk5;
import java.util.ArrayList;
import java.util.List;
import static java.util.Collections.*;//静态导入，导入是指定的类中的静态成员。
import static java.lang.System.*;
public class StaticImportDemo {
/**
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
max(list);
min(list);
out.println("hello itcast");
}
}
MathDemo
package cn.itcast.api.f.otherapi;
import java.util.Random;
public class MathDemo {
/**
* @param args
*/
public static void main(String[] args) {
/*
* Math数序运算。方法都是静态的。
* Math.PI
*/
// Math.abs(-4);
double d1 = Math.ceil(-12.34); //获取参数右边的整数 //11 12floor 12.34 ceil13 14 15
double d2 = Math.floor(12.34);//获取参数左边的整数。
double d3 = Math.round(12.54);//四舍五入。
// System.out.println("d1="+d1);//13
// System.out.println("d2="+d2);//12
// System.out.println("d3="+d3);
// System.out.println(Math.pow(10,3));
Random r = new Random();
for(int x=0; x<10; x++){
// int d = (int)(Math.random()*6 + 1);
// double d = Math.ceil(Math.random()*6);
int num = r.nextInt(6)+1;
System.out.println(num);
}
}
}
SystemDemo
package cn.itcast.api.f.otherapi;
import java.util.Properties;
import java.util.Set;
public class SystemDemo {
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
/**
* @param args
*/
public static void main(String[] args) {
/*
* System:
* 1，不需要实例化，都是静态的属性和方法。
* 2，out对应标准输出流(显示器)，int属性对应的是键盘。
* 演示一些System类中的方法。
* currentTimeMilles:获取当前时间。可以用于计算程序运行时间只要将开始时间和结束时间相减即可。
*/
long time = System.currentTimeMillis();
System.out.println(time);//毫秒值。1382691495296
//演示getProperties()获取系统属性集。
Properties prop = System.getProperties();
//获取系统属性集中的信息，遍历Properties集合。使用map的方法没问题，但是map有泛型取出时要强转。
//Properties有没有提供自身获取数据的方法呢？
//获取键集合。
// Set<String> keySet = prop.stringPropertyNames();
// for(String key : keySet){
// String value = prop.getProperty(key);//通过键获取值。
// System.out.println(key+"::::"+value);
// }
//获取指定信息，比如：操作系统。
String osname =System.getProperty("os.name");
System.out.println(osname);
//获取系统中的行分隔符。这样该程序在移植时，很方便。不同的系统，获取该系统上行分隔符
System.out.println("hello"+LINE_SEPARATOR+"itcast");
}
}
Student
package cn.itcast.domain;
public class Student implements Comparable<Student> {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
int temp = this.age - o.age;
return temp==0?this.name.compareTo(o.name):temp;
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
