Java笔记第三弹
Map集合的获取功能
V get(Object key);//根据键获取值
Set<K> keySet();//获取所有键的集合
Collection<K> values();//获取所有值的集合
Set<Map.Entry<K,V>>entrySet();//获取所有键值对对象的集合
相关应用：
//获取值
System.out.println(map.get("1"));//如果存在，返回相应键值 反之，返回null
//获取所有键的集合
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("1","lili");
map.put("2","zhangliang");
map.put("3","wangwu");
Set<String> keySet=map.keySet();
for(String ss:keySet){
System.out.println(ss);
}
}
}
//获取所有值的集合
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("1","lili");
map.put("2","zhangliang");
map.put("3","wangwu");
Collection<String> cc=map.values();
for(String ss:cc){
System.out.println(ss);
}
}
}
Map集合的遍历方式
//方式一
import java.util.*;
public class Main {
public static void main(String[] args){
Map<String> mm=new HashMap<String>();
mm.put("1","zhangliang");
mm.put("2","lili");
mm.put("3","wangwu");
Set<String> ss=map.keySet();
for(String s:ss){
String value=mm.get(s);
System.out.println(s+","+value);
}
}
}
//方式二
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("1","lili");
map.put("2","zhangliang");
map.put("3","wangwu");
Set<Map.Entry<String,String>> ss=map.entrySet();
for(Map.Entry<String,String> mm:ss){
String key=mm.getKey();
String value=mm.getValue();
System.out.println(key+","+value);
}
}
}
案例：HashMap集合存储学生对象并遍历
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<String,Student> map=new HashMap<String,Student>();
Student s1=new Student("zhangliang",19);
Student s2=new Student("wangwu",20);
Student s3=new Student("lili",18);
map.put("12",s1);
map.put("23",s2);
map.put("34",s3);
//方式一
Set<String> sss=map.keySet();
for(String sa:sss){
Student value=map.get(sa);
System.out.println(sa+","+value.getName()+","+value.getAge());
}
//方式二
Set<Map.Entry<String,Student>> ss=map.entrySet();
for(Map.Entry<String,Student> me:ss){
String key=me.getKey();
Student value=me.getValue();
System.out.println(key+","+value.getName()+","+value.getAge());
}
}
}
//Student.java已经省略
HashMap集合存储学生对象并遍历
//Main.java
import java.util.*;
public class Main {
public static void main(String[] args) {
Map<Student, String> map=new HashMap<Student,String>();
Student s1=new Student("wangwu",19);
Student s2=new Student("lili",18);
Student s3=new Student("lisi",20);
map.put(s1,"shi");
map.put(s2,"jia");
map.put(s3,"zhuang");
Set<Student> set=map.keySet();
//方式一
for(Student s:set){
String value=map.get(s);
System.out.println(s.getName()+","+s.getAge()+","+value);
}
System.out.println("----------------------");
//方式二
Set<Map.Entry<Student,String>> ss=map.entrySet();
for(Map.Entry<Student,String> me:ss){
Student key=me.getKey();
String value=me.getValue();
System.out.println(key.getName()+","+key.getAge()+","+value);
}
}
}
//Student.java已省略
案例：ArrayList集合存储HashMap元素并遍历
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<HashMap<String,String>> arr=new ArrayList<HashMap<String,String>>();
HashMap<String,String> hh=new HashMap<String,String>();
hh.put("1","3");
hh.put("2","4");
hh.put("5","7");
arr.add(hh);
for(HashMap<String,String> me:arr){
Set<String> keyset=hh.keySet();
for(String ss:keyset){
String s1=hh.get(ss);
System.out.println(ss+","+s1);
}
}
}
}
案例：HashMap集合存储ArrayList元素并遍历
import java.util.*;
public class Main {
public static void main(String[] args) {
HashMap<String,ArrayList<String>> hm=new HashMap<String,ArrayList<String>>();
ArrayList<String> arr=new ArrayList<String>();
arr.add("shi");
hm.put("石",arr);
Set<String> keyset=hm.keySet();
for(String s:keyset){
ArrayList<String> aa=hm.get(s);
for(String mm:aa){
System.out.println(mm);
}
}
}
}
案例：统计字符串中每个字符出现的次数
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//输入字符串
String s=sc.nextLine();
HashMap<Character,Integer> hm=new HashMap<Character,Integer>();
for(int i=0;i<s.length();i++){
char key= s.charAt(i);//键
Integer ii=hm.get(key);
if(ii==null){
hm.put(key,1);
}else{
ii++;
hm.put(key,ii);
}
}
//分割
StringBuilder sb=new StringBuilder();
Set<Character> keyset=hm.keySet();
for(Character key:keyset){
Integer value=hm.get(key);
//拼接
sb.append(key).append("(").append(value).append(")");
}
//转换为字符串
String result=sb.toString();
//输出
System.out.println(result);
}
}
Collections
针对集合操作的工具类
public static <T extends Comparable<?super T>> void sort(List<T> list);//升序排列
public static void reverse(List<?> list);//反转指定列表中元素的顺序
public static void shuffle(List<?> list);//使用默认的随机源随机排列指定的列表
相关应用：
//升序排列
Collections.sort(ll);
//反转既定序列
Collections.reverse(ll);
//随机排序
Coolections.shuffle(ll);
案例：ArrayList存储学生对象并排序
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<Student> arr=new ArrayList<Student>();
Student s1=new Student("lili",19);
Student s2=new Student("wangwu",19);
Student s3=new Student("zhangliang",18);
arr.add(s1);
arr.add(s2);
arr.add(s3);
Collections.sort(arr, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num=s1.getAge()-s2.getAge();
int num2=num==0?s1.getName().compareTo(s2.getName()):num;
return num2;
}
});
for(Student s:arr){
String name=s.getName();
int age=s.getAge();
System.out.println(name+","+age);
}
}
}
案例：模拟斗地主
//基础版
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<String> arr=new ArrayList<String>();
//定义花色数组
String[] colors={"","","",""};
//定义数字数组
String[] numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for(String color:colors){
for(String number:numbers){
arr.add(color+number);
}
}
arr.add("小王");
arr.add("大王");
//洗牌
Collections.shuffle(arr);
//发牌
ArrayList<String> aarr=new ArrayList<String>();
ArrayList<String> barr=new ArrayList<String>();
ArrayList<String> carr=new ArrayList<String>();
ArrayList<String> darr=new ArrayList<String>();
for(int i=0;i<arr.size();i++){
String poker=arr.get(i);
if(i>=arr.size()-3){
darr.add(poker);
}else if(i%3==0){
aarr.add(poker);
}else if(i%3==1){
barr.add(poker);
}else{
carr.add(poker);
}
}
looker("a",aarr);
looker("b",barr);
looker("c",carr);
looker("d",darr);
}
public static void looker(String name,ArrayList<String> arr){
System.out.println(name+"的牌是：");
for(String poker:arr){
System.out.println(poker+" ");
}
}
}
//升级版
import java.util.*;
public class Main {
public static void main(String[] args) {
HashMap<Integer,String> hm=new HashMap<Integer,String>();
ArrayList<Integer> arr=new ArrayList<Integer>();
//定义花色数组
String[] colors={"","","",""};
//定义数字数组
String[] numbers={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
int index=0;
for(String number:numbers){
for(String color:colors){
hm.put(index,color+number);
arr.add(index);
index++;
}
}
hm.put(index,"小王");
arr.add(index);
index++;
hm.put(index,"大王");
arr.add(index);
//洗牌
Collections.sort(arr);
//发牌
TreeSet<Integer> aarr=new TreeSet<Integer>();
TreeSet<Integer> barr=new TreeSet<Integer>();
TreeSet<Integer> carr=new TreeSet<Integer>();
TreeSet<Integer> darr=new TreeSet<Integer>();
for(int i=0;i<arr.size();i++){
if(i>=arr.size()-3){
darr.add(arr.get(i));
}else if(i%3==0){
aarr.add(arr.get(i));
}else if(i%3==1){
barr.add(arr.get(i));
}else{
carr.add(arr.get(i));
}
}
looker("a",aarr,hm);
looker("b",barr,hm);
looker("c",carr,hm);
looker("d",darr,hm);
}
public static void looker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
System.out.println(name+"的牌是： ");
for(Integer key:ts){
String poker=hm.get(key);
System.out.println(poker+" ");
}
}
}
File类
是文件和目录路径名的抽象表示
File(String pathname);//将字符串转变为抽象路径名
File(String parent,String child);//从父路径名字符串和子路径名字符串创建新的File实例
File(File parent,String child);//从父抽象路径名和子路径名字符串创建新的File实例
相关应用：
//仅仅能够显示，并不要求该文件存在
File f1=new File("E:\\itcast\\java.txt");
System.out.println(f1);
//显示内容与上述一致
File f1=new File("E:\\itcast","java.txt");
System.out.println(f1);
//显示内容与上述一致
File f1=new File("E:\\itcast");
File f2=new File(f1,"java.txt");
System.out.println(f2);
Java笔记第三弹的更多相关文章
- Effective java笔记（三），类与接口
类与接口是Java语言的核心,设计出更加有用.健壮和灵活的类与接口很重要. 13.使类和成员的可访问性最小化 设计良好的模块会隐藏起所有的实现细节,仅使用API与其他模块进行通信.这个概念称为信息隐藏 ...
- Java笔记（三）异常
异常 一.概念 一)为什么会有Java异常机制 在没有Java异常机制的情况下,唯一的退出机制就是返回值,判断是否异常的方法就是 返回值.方法根据是否异常返回不同的返回值,调用者根据不同的返回值进行判 ...
- 菜鸡的Java笔记 第三十七 - java 线程与进程
线程与进程 线程与进程的区别 最早的的时候DOS 系统有一个特点:只要电脑有病毒,那么电脑就死机了,是因为传统的DOS 系统属于单进程的操作系统 ...
- 菜鸡的Java笔记 第三十四 Annotation
Annotation 多例模式特点: 1. 多例类可以有多个实例 2. 多例类必须自己创建自己的实例,并管理自己的实例,和向外界提供自己的实例 ...
- 菜鸡的Java笔记 第三十三 - java 泛型
泛型 GenericParadigm 1.泛型的产生动机 2.泛型的使用以及通配符 3.泛型方法的使用 JDK1.5 后的三大主 ...
- 菜鸡的Java笔记 第三十 - java 异常的捕获及处理
异常的捕获及处理 1.异常的产生分析以及所带来的影响 2.异常的处理的基本格式 3.异常的处理流程 4.异常的处理模式 5.自定义 ...
- 菜鸡的Java笔记 第三十五 接口定义增强
接口定义增强 在java从一开始到现在接口之中的核心组成部分:抽象方法与全局常量,但是随着技术的不断发展,用户在使用过程之中发现了有一些问题 如果说现在有一个接口经过了长年 ...
- 菜鸡的Java笔记 第三十六 - java 函数式编程
StudyLambda Lambda 指的是函数式编程,现在最为流行的编程模式为面向对象,很多的开发者并不认可面向对象,所以很多的开发者宁愿继续使用 C 语言进行开发,也不愿意使用java,c+ ...
- 菜鸡的Java笔记 第三十一 扩展结构
.新特性 可变参数的意义以及实现 那么下面通过一个简单的思考来分析可变参数的存在意义 范例:如果说现在要定义一个方法,这个方法可以实现任意多个 ...
- 菜鸡的Java笔记 第三十二 - java 静态导入的实现
静态导入的实现 为了理解静态导入的操作产生的动机,下面通过一个具体的代码来观察 范例:现在有一个 Import 的类,这个类中的方法全部都是 static 方法 packa ...
随机推荐
- lui - pager - 分页
pager - 分页 demo lui demo <template> <div class="app-container"> <h3>el-p ...
- Java基础——数组的初始化与赋值、循环遍历，Random随机数[大于等于0，小于所给值)
package com.zhao.demo; public class Demo05 { //数组的静态初始化 /*public static void main(String[] args) { i ...
- Linux 系统挂载 ntfs 移动硬盘无法写入的问题
linux 下挂载 ntfs 移动硬盘无法写入问题 在机房使用移动硬盘时发现无法写入硬盘,具体是 Ubuntu 21.04 ,移动硬盘是 SSD ,分区类型是 NTFS . 首先百度得知最优办法是安装 ...
- Java-Java数据类型对应MySql数据类型
开发过程中常用的数据类型: Java Mysql 备注 整型 java.lang.Integer tinyint(m) 1个字节 范围(-128~127) java.lang.Integer ...
- springboot修改默认端口
方案一: src/main/resuorces 文件夹下新建application.properties 文件 并添加内容server.port=8011即可 方案二: 使用EmbeddedServl ...
- h5移动端识别二维码信息
jsqr插件 图片跨域时不允许绘制到canvas,所以先转blob在画到canvas上面就可以,如果不跨域直接画就行 function getImageBlob (url) { ...
- https://计算机等级分类总结
4个等级: 一级:定位为满足人们在一般性工作中对计算机的应用,重点是操作能力的考核: 二级:定位为计算机程序员,可谓"计算机蓝领". 三级:定位为"开发工程师" ...
- 面向对象3（Java）
多态 基本介绍 即同一方法可以根据发送对象的不同而采用多种不同的行为方式 一个对象的实际类型是确定的,但是可以指向对象的引用类型可以很多 多态存在的条件:a.有继承关系:b.子类重写父类方法:c.父类 ...
- Java中多态相关知识点
多态 1.多态概述 同一个对象在不同时刻表现出的不同形态 多态的前提和体现: 有继承/实现关系 有方法重写 有父类引用指向子类对象(Animal a = new Cat();) 2.多态中的成员访问特 ...
- Java的流程控制
Scanner对象 next(); 一定要读取到有效字符后才可以结束输入. 对输入有效字符之前遇到的空白,next()方法会自动将其去掉(). 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束 ...