java基础
1.JDK
JDK :java development kit
JRE:java runtime environment
JDK包含JRE
java跨平台:因为java程序运行依赖虚拟机,虚拟机需要有对应操作系统的版本,而jre中有虚拟机。
当你想要在Linux系统下运行,则需要安装对应的虚拟机,及对应的jdk版本,而对应的jdk版本中的jre有对应的虚拟机
2.标识符:我们自己定义的名字
类名:不能以数字开头,只能有_ $ 字母 数字
类方法:前面小写,第二个单词大写。
3.常量:不能变的值。system.out.println(100);
4.变量:指在计算机内存中,可以随时改变的量。int i = 2; system.out.println(i);
【注意:八个比特等于一个字节】
5.算术运算符:int a=3; int b = a++ + 10;a=4,b=13
6.数据类型:范围 byte<short<int<long<float<double
7.方法:
注意点:
1.方法不能定义在另一个方法里面
2.调用方法时,返回值是void,不能写在输出语句中
3.方法重载:
1.参数列表必须不同
2.重载和参数变量名无关
3.重载和返回值类型无关
4.重载和修饰符无关
总结:重载只看方法名和参数列表
当把方法中的void改为int并且加个返回值return ;则需要在main方法中调用change方法的同时需要给其赋值。如:a=change(a,b);否则还是会出现上面这种a,b不变的情况。
为什么这个方法跟上面差不多,只是把参数换了个引用类型参数,结果就能成功赋值?
因为int[] arr = [1,2,3,4];在堆上开辟了一个容器,且有个地址返回给int[] arr,当你调用change,将arr[2]赋值为100,则方法会根据地址去对对应的arr[2]进行赋值,方法结束时,change退出方法栈,但是此时值以及改好。
ArrayList<>:<>里面存放的是引用数据类型。如:int的引用数据类型是integer(四类八种中有两个基本数据类型和引用数据类型不同,一个是int(integer),一个是char(character))
=============================================================
transient:在不需要序列化的属性前面加个transient,则序列化对象的时候,这个属性就不会被序列化。
序列化
package com.li.demo01;
import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
public class iterator {
public static void main(String[] args) throws IOException, ClassNotFoundException {
File file = new File("xxx.txt");
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream op = new ObjectOutputStream(fos);
User user = new User(1,2);
op.writeObject(user);
op.flush();
op.close();
System.out.println(user);
System.out.println("=========================================");
FileInputStream fls = new FileInputStream(file);
ObjectInputStream oi = new ObjectInputStream(fls);
User user1 = (User) oi.readObject();
System.out.println(user1);
}
}
实体类
package com.li.demo01;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = -134246534L;
private int id;
transient int age;
public User() {
}
public User(int id, int age) {
this.id = id;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
'}';
}
}
输出结果
User{id=1, age=2}
=========================================
User{id=1, age=0}
进程已结束,退出代码 0
面向对象
1.成员变量与局部变量的不同
局部变量没有赋值不能输出,成员变量可以。
public class demo7 {
static int x;
public void run(){
int i;
System.out.println(i);//注意这里的i会报错,因为i为局部变量,局部变量没有赋值,是不能进行输出。
}
public static void main(String[] args) {
System.out.println(x);
}
}
内存位置不同
生命周期不同
成员变量,跟随对象,在堆中存储,内存等待JVM清理,生命周期较长
局部变量,跟随方法,方法出栈,生命周期相对较短。
注意:重点需要会掌握如何区分局部还是成员变量即可。
面向对象方法参数:基本数据类型和引用数据类型
基本数据类型
引用数据类型
private修饰词
只能修饰成员变量,不能修饰局部变量
总结:类中不需要对外提供的内容都私有化,包括属性的方法。
以后再描述事物,属性都私有化,并提供setXXX getXXX方法对其进行访问。
注意:私有仅仅是封装的体现形式而已。
this关键字
区分成员变量和局部变量的同名的情况
方法中访问成员变量,写this.
凡是写this. 的都是访问成员变量。
this的使用年纪的比较
extend继承
当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用关键字super来完成。
this. 调用自己本类成员
super. 调用的自己的父类成员
重写:子类和父类方法一样(参数名一样)的时候。(注意区别于重载,重载是参数不一样)
子类重写父类的方法,保证子类方法的权限大于或者等于父类方法权限
四大权限 public protected default private (方法默认是default权限)
abstract
抽象类,不能实例化对象,不能new对象。
不能创建对象的原因:如果你真的实例化对象了,对象.调用抽象方法,但是抽象方法中没有方法体,根本不能运行。
抽象类强制它的子类执行抽象方法,重写父类的方法,就不需要写抽象修饰词,加上主体即可。
2.4抽象类的细节问题:
1、抽象类一定是个父类?
是的,因为不断抽取而来的。
2、抽象类中是否可以不定义抽象方法。
是可以的,那这个抽象类的存在到底有什么意义呢?不让该类创建对象,方法可以直接让子类去使用
3、抽象关键字abstract不可以和哪些关键字共存?
1、private:私有的方法子类是无法继承到的,也不存在覆盖,而abstract和private一起使用修饰方法,abstract既要子类去实现这个方法,而private修饰子类根本无法得到父类这个方法。互相矛盾。
2、final,暂时不关注,后面学
3、static,暂时不关注,后面学
接口
定义抽象方法:固定格式 public abstract 返回值类型 方法名字(参数列表);
修饰符 public 写,或者不写都是public。但是别的地方不写则是default。
接口中定义变量:固定格式:public static final 数据类型 变量名 = 值;(并且因为,static,所以它可以直接通过接口的名字直接调用它)我们不写前面这些修饰词,不代表没有,接口会自动写进去。
如:
注意点:接口和继承中当你实现接口,或者继承类时强制要求你写出方法是因为其中的abstract的原因。
继承父类,当父类中方法有abstract,则继承时就需要重写。
类对接口方法的实现的时候,不管接口中是否有写public abstract都需要加上public
实现多个接口
实现多个接口需要避免这个情况
抽象类和接口的区别:
抽象类是这个体系应该有的东西,而接口是体系中额外的扩展功能
interface 缉毒{
public abstract void 缉毒();
}
//定义犬科的这个提醒的共性功能
abstract class 犬科{
public abstract void 吃饭();
public abstract void 吼叫();
}
// 缉毒犬属于犬科一种,让其继承犬科,获取的犬科的特性,
//由于缉毒犬具有缉毒功能,那么它只要实现缉毒接口即可,这样即保证缉毒犬具备犬科的特性,也拥有了缉毒的功能
class 缉毒犬 extends 犬科 implements 缉毒{
public void 缉毒() {
}
void 吃饭() {
}
void 吼叫() {
}
}
class 缉毒猪 implements 缉毒{
public void 缉毒() {
}
}
多态
多态体现为父类引用变量可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。
在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
如:接口 变量 = new 实现类():
********
父类
public class Animal {//父类
static int cons = 1;
int val = 1;
final int fin = 1;
public void eat() {
System.out.println("animal eat");
}
static void eat2() {
System.out.println("animal eat2");
}
}
子类
public class Cat extends Animal{
static int cons = 2;
int val = 2;
final int fin = 2;
@Override
public void eat() {
System.out.println("cat eat");
}
static void eat2() {
System.out.println("cat eat2");
}
}
测试类(调用父子类中一样的方法,则输出结果是子类的方法,要想调用父类的方法,需要在父类中加上static。
调用父子类中的成员,默认输出结果是父类的成员变量。原因【编译、运行都是跟着父类走】且通过多态调用的成员变量,无论是普通类型,静态类型,常量类型仍是父类的成员变量,因为成员变量不存在override(覆盖)问题)
public static void main(String[] args) {
Animal a = new Cat();//父类引用
System.out.println(a.val);//成员变量
System.out.println(a.cons);//静态变量
System.out.println(a.fin);//常量
a.eat();//成员方法
a.eat2();//静态方法
}
输出结果
1
1
1
cat eat
animal eat2
instanceof判断变量p是Student还是Teacher(前提:两个类都需要继承Person)。
格式:引用变量 instanceof 类名
boolean a = p instanceof Student;
Person p = new Stduent();Person p = new Teacher();【Teacher 向上转型(优点:可以调用子类和父类的共有内容。缺点:不能调用子类中特有的内容。如何解决缺点:可以加强转。如:Teacher t = (Teacher)p;
)】
构造方法的作用:当我们new对象的时候自动赋值上去。以往都是new完对象再赋值。
构造方法的定义格式
权限 方法名(参数列表){
}
方法的名字,必须和类的名字完全一致
构造方法不允许写返回值类型,void也不能写。
当你new对象的时候,构造方法就执行,而且仅执行一次
this在构造方法之间的调用:
this():减轻了无参构造的代码量。
package cn.itcast.demo03;
/*
* this可以在构造方法之间进行调用
* this.的方式,区分局部变量和成员变量同名情况
* this在构造方法之间的调用,语法 this()
*/
public class Person {
private String name;
private int age;
public Person(){
//调用了有参数的构造方法
//参数李四,20传递给了变量name,age
this("李四",20);//调用this()需要让它再构造方法的第一行
}
/*
* 构造方法,传递String,int
* 在创建对象的同时为成员变量赋值
*/
public Person(String name,int age){
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;
}
}
package cn.itcast.demo03;
public class Test {
public static void main(String[] args) {
//创建Person的对象,调用的是空参数的构造方法
//运行的结果 null 0
Person p = new Person();
System.out.println(p.getName());
System.out.println(p.getAge());
}
}
内存图
super关键字
父类
子类
测试类
我们发现,当我们new一个子对象的时候,输出父类中无参构造的值。说明我们子类中有隐藏的
public zi(){
super();
}
这段代码
须知:子类中的构造方法是用来调用父类方法的。(super含义:标明了父类文件所在的内存区域)
内存图
注意点:子类中所有的构造方法,无论重载多少个,第一行必须是super()
如:
父类
/*
* 手动写一个父类Person类的构造方法,加入int类型参数
* 保存,子类就报错
*/
public class Person {
public Person(int a){
}
public Person(double d){
}
}
子类
/*
* 子类构造方法的报错原因: 找不到父类的空参数构造器
* 子类中,没有手写构造,编译器添加默认的空参数
* public Student(){
* super();
* }
* 编译成功,必须手动编写构造方法,请你在super中加入参数
*
* 注意: 子类中所有的构造方法,无论重载多少个,第一行必须是super()
* 如果父类有多个构造方法,子类任意调用一个就可以
* super()语句必须是构造方法第一行代码
*/
public class Student extends Person{
public Student(){
super(0.1);
}
public Student(String s){
super(1);
}
}
案例:
父类
public class Person extends Object{
public Person(int a) {
}
}
子类
/*
构造方法第一行,写this()还是super()
不能同时存在,任选其一,保证子类的所有构造方法调用到父类的构造方法即可
小结论: 无论如何,子类的所有构造方法,直接,间接必须调用到父类构造方法
子类的构造方法,什么都不写,默认的构造方法第一行 super();
*/
public class Student extends Person{
public Student(){
//调用的是自己的构造方法
//间接形式调用到了父类的构造方法
this("abc");
}
public Student(String s){
super(1);
}
}
测试类
public class Test {
public static void main(String[] args) {
new Student();
}
}
final修饰引用变量问题
变量,保存内存地址,终身不变
final Zi z2 = new Zi();
z2 = new Zi();
* final修饰成员变量
- 成员变量,在堆内存,具有默认值
- final修饰的成员变量,固定的不是内存的默认值
- 固定的是,成员变量的手动赋值,绝对不是内存的默认
- 成员变量的赋值,2种实现方式,一种是定义的时候,直接=赋值
- 另一种赋值方式,采用构造方法赋值
- 保证: 被final修饰的成员变量,只能被赋值一次
- 成员变量,需要在创建对象前赋值,否则报错
- 构造方法,是创建对象中的事情,可以为成员变量赋值
- setXXX方法,创建对象之后的时候,不能为final修饰的成员赋值
static
静态不能写this,不能写super。因为this表示本类的对象引用,而静态优先于对象
当我们的方法不是静态方法的时候,我们就需要去先new一个对象,才能调用那个方法。解决:那个方法为静态则可以不用new直接调用。
内部类
调用规则:内部类,可以使用外部类成员,包括私有外部类要使用内部类的成员,必须建立内部类对象。
匿名内部类
定义实现类,重写方法,创建实现类对象,一步搞定
格式: new 接口或者父类(){
重写抽象方法
}
导包
classpath是帮助虚拟机找到jar包的位置
在命令窗口也可配置 如:set classpath=d:\method.jar
在eclipse中直接在项目点击右键创建一个folder为lib,再把要导入的jar包放进去即可。
String
Calendar
/*
* 闰年计算
* 2000 3000
* 高级的算法: 日历设置到指定年份的3月1日,add向前偏移1天,获取天数,29闰年
*/
public static void function_1(){
Calendar c = Calendar.getInstance();
//将日历,设置到指定年的3月1日
c.set(2088, 2, 1);
//日历add方法,向前偏移1天
c.add(Calendar.DAY_OF_MONTH, -1);
//get方法获取天数
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
}
自动装拆箱
/*
* JDK1.5后出现的特性,自动装箱和自动拆箱
* 自动装箱: 基本数据类型,直接变成对象
* 自动拆箱: 对象中的数据变回基本数据类型
*/
public class IntegerDemo2 {
public static void main(String[] args) {
function_2();
}
/*
* 关于自动装箱和拆箱一些题目
*/
public static void function_2(){
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i==j);// false 对象地址
System.out.println(i.equals(j));// true 继承Object重写equals,比较的对象数据
System.out.println("===================");
Integer a = 500;
Integer b = 500;
System.out.println(a==b);//false
System.out.println(a.equals(b));//true
System.out.println("===================");
//数据在byte范围内,JVM不会从新new对象
Integer aa = 127; // Integer aa = new Integer(127)
Integer bb = 127; // Integer bb = aa;
System.out.println(aa==bb); //true
System.out.println(aa.equals(bb));//true
}
//自动装箱和拆箱弊端,可能出现空指针异常
public static void function_1(){
Integer in =null;
//in = null.intValue()+1
in = in + 1;
System.out.println(in);
}
//自动装箱,拆箱的 好处: 基本类型和引用类直接运算
public static void function(){
//引用类型 , 引用变量一定指向对象
//自动装箱, 基本数据类型1, 直接变成了对象
Integer in = 1; // Integer in = new Integer(1)
//in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型
//in+1 ==> in.inValue()+1 = 2
// in = 2 自动装箱
in = in + 1;
System.out.println(in);
}
}
集合
java中三种长度表现形式
数组. length 属性 返回值int
字符串.length() 方法,返回值int
集合.size()方法,返回值int
public static void function(){
Collection coll = new ArrayList();
coll.add("abc");
coll.add("rtyg");
coll.add("43rt5yhju");
//注意要想获取String的长度,必须先向下转型
Iterator it = coll.iterator();
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s.length());
}
}
//该转型存在安全隐患,如:当我们coll.add(1);增加整数时,由于jdk中的自动装箱特性,就会把整数转为Integer。此时下面的转型会报异常,因为Integer不能转为String。
//所以,我们在写集合的时候,最好将泛型加上去,也就是在集合后面指定该存储的类型。
泛型:当我们写集合时候,不在集合后面加<>,这样的话,当我们在集合中增加多种数据时,如,整数、字符串等,就会发生报错,加上<>并指定数据类型,这样就可以把在编译之后报的错,提前到编译阶段,因为编译后的.class文件不会显示出泛型,我们又把编译阶段可能出现多种数据类型,对其在编译阶段就报错,这样就可以保证其安全性,这是在JDK1.5版本后加上的特性。
/*
* 将的酒店员工,厨师,服务员,经理,分别存储到3个集合中
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法
*/
import java.util.ArrayList;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
//创建3个集合对象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();
//每个集合存储自己的元素
cs.add(new ChuShi("张三", "后厨001"));
cs.add(new ChuShi("李四", "后厨002"));
fwy.add(new FuWuYuan("翠花", "服务部001"));
fwy.add(new FuWuYuan("酸菜", "服务部002"));
jl.add(new JingLi("小名", "董事会001", 123456789.32));
jl.add(new JingLi("小强", "董事会002", 123456789.33));
// ArrayList<String> arrayString = new ArrayList<String>();
iterator(jl);
iterator(fwy);
iterator(cs);
}
/*
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
* ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
* 强制转换: it.next()=Object o ==> Employee
* 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
* 泛型的限定 本案例,父类固定Employee,但是子类可以无限?
* ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
* ? super Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
* 不写继承Employee的话什么参数都能传进来,如,ArrayList<String> array = new ArrayList<String>();
*/
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//获取出的next() 数据类型,是什么Employee
Employee e = it.next();
e.work();
}
}
}
/*
* List接口派系, 继承Collection接口
* 下面有很多实现类
* List接口特点: 有序,索引,可以重复元素
* 实现类, ArrayList, LinkedList
*
* List接口中的抽象方法,有一部分方法和他的父接口Collection是一样
* List接口的自己特有的方法, 带有索引的功能
*/
public class ListDemo {
public static void main(String[] args) {
function_2();
}
/*
* E set(int index, E)
* 修改指定索引上的元素
* 返回被修改之前的元素
*/
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);
System.out.println(i);
System.out.println(list);
}
/*
* List接口中的方法:
* set和add有区别,虽然都可以按照索引导入数
* 据,但是set不能超过数组长度去导入数据,
* 就是说set只能在原有的数组中进行导入,而
* add可以。
*
*/
/*
* E remove(int index)
* 移除指定索引上的元素
* 返回被删除之前的元素
*/
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);
System.out.println(d);
System.out.println(list);
}
/*
* add(int index, E)
* 将元素插入到列表的指定索引上
* 带有索引的操作,防止越界问题
* java.lang.IndexOutOfBoundsException
* ArrayIndexOutOfBoundsException
* StringIndexOutOfBoundsException
*/
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "itcast");
System.out.println(list);
}
}
遍历数组有三种方法:
第一种:迭代方法
//迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
第二种:for循环
for(int i = 0; i < list.size(); i++){
String str = list.get(i);
System.out.println(str);
}
第三种:增强的for循环
for(String s : str){
System.out.println(s.length());
}
集合
ArrayList集合适用于查询操作的时候,LinkedList集合适用于增删操作LinkedList详细信息。
set和list的区别,set不能存储同样的数据,list可以
Map遍历方式
①
public class EntryDemo {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1, "2ad");
map.put(2, "23d");
map.put(3, "12ad");
Set<Map.Entry<Integer,String>> set = map.entrySet();
Iterator<Map.Entry<Integer, String>> it = set.iterator();
while(it.hasNext()){
Entry<Integer, String> next = it.next();
Integer key = next.getKey();
String value = next.getValue();
System.out.println(key+value);
}
}
}
②
public class EntryDemo {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("2ad", 1);
map.put("23d", 2);
map.put("12ad", 3);
Set<String> keySet = map.keySet();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()){
String next = iterator.next();
System.out.println(next);
}
}
}
或者用增强for
for(Map.Entry<String, Integer> entry : map.entrySet()){
System.out.println(entry);
}
注意:增强for不能遍历map,我们上面这个例子是遍历set,通过间接遍历map,不能直接遍历map。
理由:因为Iterable下面没有Map什么事,所以增强for不能遍历map。
注意点:
当我们把String写后面不写前面时候,这样遍历的结果,即使有重复的,也会直接打印输出出来。
此时解决方法:可以在Person类中重写hashCode和equals方法,即可解决出现重复数据的情况。
vector
静态导入
/*
* JDK1.5新特性,静态导入
* 减少开发的代码量
* 标准的写法,导入包的时候才能使用
*
* import static java.lang.System.out;最末尾,必须是一个静态成员
*/
import static java.lang.System.out;
import static java.util.Arrays.sort;
public class StaticImportDemo {
public static void main(String[] args) {
out.println("hello");
int[] arr = {1,4,2};
sort(arr);
}
}
可变参数
/*
* JDK1.5新的特性,方法的可变参数
* 前提: 方法参数数据类型确定,参数的个数任意
* 可变参数语法: 数据类型...变量名
* 可变参数,本质就是一个数组
*/
public class VarArgumentsDemo {
public static void main(String[] args) {
//调用一个带有可变参数的方法,传递参数,可以任意
// getSum();
int sum = getSum(5,34,3,56,7,8,0);
System.out.println(sum);
function(1,2,3);
}
/*
* 可变参数的注意事项
* 1. 一个方法中,可变参数只能有一个
* 2. 可变参数,必须写在参数列表的最后一位
*/
public static void function(Object...o){
}
public static void function(int a,int b,int...c){
}
/*
* 定义方法,计算10个整数和
* 方法的可变参数实现
*/
public static int getSum(int...a){
int sum = 0 ;
for(int i : a){
sum = sum + i;
}
return sum;
}
}
线程安全
Map嵌套案例
/*
* Map集合的嵌套,Map中存储的还是Map集合
* 要求:
* 传智播客
* Java基础班
* 001 张三
* 002 李四
*
* Java就业班
* 001 王五
* 002 赵六
* 对以上数据进行对象的存储
* 001 张三 键值对
* Java基础班: 存储学号和姓名的键值对
* Java就业班:
* 传智播客: 存储的是班级
*
* 基础班Map <学号,姓名>
* 传智播客Map <班级名字, 基础班Map>
*/
public class MapMapDemo {
public static void main(String[] args) {
//定义基础班集合
HashMap<String, String> javase = new HashMap<String, String>();
//定义就业班集合
HashMap<String, String> javaee = new HashMap<String, String>();
//向班级集合中,存储学生信息
javase.put("001", "张三");
javase.put("002", "李四");
javaee.put("001", "王五");
javaee.put("002", "赵六");
//定义传智播客集合容器,键是班级名字,值是两个班级容器
HashMap<String, HashMap<String,String>> czbk =
new HashMap<String, HashMap<String,String>>();
czbk.put("基础班", javase);
czbk.put("就业班", javaee);
//keySet(czbk);
entrySet(czbk);
}
public static void entrySet(HashMap<String,HashMap<String,String>> czbk){
//调用czbk集合方法entrySet方法,将czbk集合的键值对关系对象,存储到Set集合
Set<Map.Entry<String, HashMap<String,String>>>
classNameSet = czbk.entrySet();
//迭代器迭代Set集合
Iterator<Map.Entry<String, HashMap<String,String>>> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
//classNameIt.next方法,取出的是czbk集合的键值对关系对象
Map.Entry<String, HashMap<String,String>> classNameEntry = classNameIt.next();
//classNameEntry方法 getKey,getValue
String classNameKey = classNameEntry.getKey();
//获取值,值是一个Map集合
HashMap<String,String> classMap = classNameEntry.getValue();
//调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
//迭代Set集合
Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
while(studentIt.hasNext()){
//studentIt方法next获取出的是班级集合的键值对关系对象
Map.Entry<String, String> studentEntry = studentIt.next();
//studentEntry方法 getKey getValue
String numKey = studentEntry.getKey();
String nameValue = studentEntry.getValue();
System.out.println(classNameKey+".."+numKey+".."+nameValue);
}
}
System.out.println("==================================");
for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
String classNameKey = me.getKey();
HashMap<String, String> numNameMapValue = me.getValue();
for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
String numKey = nameMapEntry.getKey();
String nameValue = nameMapEntry.getValue();
System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
}
}
}
public static void keySet(HashMap<String,HashMap<String,String>> czbk){
//调用czbk集合方法keySet将键存储到Set集合
Set<String> classNameSet = czbk.keySet();
//迭代Set集合
Iterator<String> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
//classNameIt.next获取出来的是Set集合元素,czbk集合的键
String classNameKey = classNameIt.next();
//czbk集合的方法get获取值,值是一个HashMap集合
HashMap<String,String> classMap = czbk.get(classNameKey);
//调用classMap集合方法keySet,键存储到Set集合
Set<String> studentNum = classMap.keySet();
Iterator<String> studentIt = studentNum.iterator();
while(studentIt.hasNext()){
//studentIt.next获取出来的是classMap的键,学号
String numKey = studentIt.next();
//调用classMap集合中的get方法获取值
String nameValue = classMap.get(numKey);
System.out.println(classNameKey+".."+numKey+".."+nameValue);
}
}
System.out.println("==================================");
for(String className: czbk.keySet()){
HashMap<String, String> hashMap = czbk.get(className);
for(String numKey : hashMap.keySet()){
String nameValue = hashMap.get(numKey);
System.out.println(className+".."+numKey+".."+nameValue);
}
}
}
}
标签:JAVA,int,基础,System,println,------,new,public,out
From: https://blog.csdn.net/Thrive_LCX/article/details/136895677