Java大全(二)
时间：2023-06-17 20:37:00
集合
-
Java集合框架： List接口：（不唯一、有序） ArrayList、LinkedList Set：(唯一、无序) HashSet、TreeSet Map：(键是唯一的，值不是唯一的) HashMap、TreeMap
1.ArryList与LinkedList
-
ArryList与LinkedList是List接口实现类，List一组接口存储不是唯一有序的对象(插入顺序有序) 例如 0 1 2 3 4 aaa bb cc aaa cc ArryList实现长度可变数组，连续空间分布在内存中，遍历元素和随机访问元素的效率相对较高 LinkedList采用链表存储方式，插入删除元素时效率较高
1.1 ArryList类常用方法
使用一种类的方法时，一定要看这种结构方法(必要的) boolean add(Object o) 在列表的末尾顺序添加元素，从0开始开始索引位置 void add(int index,Object o) 在指定的索引位置添加元素。索引位置必须介于0和列表中元素数之间 int size() 返回列表中的元素数 Object get(int index) 返回指定索引位置的元素。取出元素是Object类型在使用前需要型 boolean remove(Object o) 删除列表中的元素 Object remove(int index) 删除列表中的指定位置元素，从0开始索引位置 boolean contains(Object o) 判断列表中是否有指定元素 1.2 ArryList用各种方法的例子
import java.util.ArrayList; public class Test {
/* * 可存储各种新闻标题(包括)ID、名称、创造者) 新闻标题的总数可以获得 每个新闻标题的名称可以逐一打印 */ public static void main(String[] args) {
// 创建3个新闻标题对象 NewsTitle nt1 = new NewsTitle(1001, "合肥新站区和肥西新增1例新冠肺炎感染者", "合肥日报"); NewsTitle nt2 = new NewsTitle(1002, "今天合肥有暴雨，当地特大暴雨", "张三"); NewsTitle nt3 = new NewsTitle(1003, "令人震惊的是，程序员每天都喜欢这样做", "李四"); NewsTitle nt4 = new NewsTitle(1004, "昨天，安徽泗县新增23例冠肺炎无症状感染者", "安徽日报"); // 准备集合容器，调用ArrayList创建默认长度为10的集合容器 ArrayList al = new ArrayList(); // 将创建的新闻标题对象存储到al集合中
al.add(nt1);
al.add(nt3);
al.add(nt2);
// 获取新闻标题的总数----》获取集合中元素的个数
//int size():返回列表中的元素个数
int size = al.size();
System.out.println("集合中元素的个数：" + size);
// 可以逐条打印每条新闻标题的名称
//Object get(int index):返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
// Object obj1 =al.get(0);
// NewsTitle newsTile1 = (NewsTitle)obj1;
// System.out.println(newsTile1.getName());
//
// Object obj2 =al.get(1);
// NewsTitle newsTile2 = (NewsTitle)obj2;
// System.out.println(newsTile2.getName());
//
// Object obj3 =al.get(2);
// NewsTitle newsTile3 = (NewsTitle)obj3;
// System.out.println(newsTile3.getName());
for (int i = 0; i < al.size(); i++) {
Object obj = al.get(i);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile.getId()+"--"+newsTile.getName());
}
//void add(int index,Object o):在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
al.add(0, nt4);
NewsTitle news =(NewsTitle)al.get(0);
System.out.println(news);
//boolean contains(Object o):判断列表中是否存在指定元素，如果集合中存在你要找的元素，返回true，否则返回false
boolean result1 =al.contains(nt3);
System.out.println("集合中存在你要找的元素nt3:"+result1);
//boolean remove(Object o):从列表中删除元素，删除成功返回true，删除失败返回false
boolean result2 =al.remove(nt4);
System.out.println("删除元素成功："+result2);
for (int i = 0; i < al.size(); i++) {
Object obj = al.get(i);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile.getId()+"--"+newsTile.getName());
}
System.out.println("---------------");
//Object remove(int index):从列表中删除指定位置元素，起始索引位置从0开始
Object obj =al.remove(0);
NewsTitle newsTile = (NewsTitle) obj;
System.out.println(newsTile);
System.out.println("--------------");
for (int i = 0; i < al.size(); i++) {
Object obje = al.get(i);
NewsTitle newsTilee = (NewsTitle) obje;
System.out.println(newsTilee.getId()+"--"+newsTilee.getName());
}
//clear():清空集合中的所有元素
//al.clear();
//System.out.println(al.size());
//isEmpty():如果此列表中没有元素，则返回 true
//System.out.println(al.isEmpty());
System.out.println("--------------");
//toArray():将集合变成数组
Object[] objs =al.toArray();
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
System.out.println("--------------");
//iterator():迭代器（遍历），将集合中的元素“转移”到了迭代器这么一个容器中，接下来对迭代器容器进行遍历
Iterator it =al.iterator(); //iterator()方法是
//遍历it这个容器，先使用hasNext()方法判断容器中是否有元素，有，使用next()方法取出，然后再判断，如果有，就取出元素，继续再判断，有，继续取出
//it.hasNext():判断迭代器中是否有元素，如果有元素返回true
while(it.hasNext()){
//取出元素
Object object =it.next(); //多态
System.out.println(object);
}
System.out.println("--------------------------------------");
for(Object ob:al){
//子类重写了Object中的toString()方法，上一行代码是向上转型（多态），子类引用指向父类，所以这里的object在println()内部调用的是重写的toString()方法
System.out.println(ob);
}
}
}
1.3 LinkedList类常用方法
-
LinkedList类是List接口的一个具体实现类，它是用于创建链表数据结构，当插入或删除元素时，性能会更好 void addFirst(Object o) 在列表的首部添加元素 Object getFirst() 返回列表中的第一个元素 Object getLast() 返回列表中的最后一个元素 Object removeFirst() 删除并返回删除的这个元素 Object removeLast() 删除并返回列表中的最后一个元素 -
例子 public class Test { /* * 新闻管理系统，需求如下 可以添加头条新闻标题 获取头条和最末条新闻标题 可以删除末条新闻标题 */ public static void main(String[] args) { // 准备集合中的内容，创建3个NewsTitle类对象 NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三"); NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四"); NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五"); NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六"); NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七"); //准备容器，创建LinkedList对象 LinkedList list = new LinkedList(); list.add(nt1); list.add(nt2); list.add(nt3); list.addLast(nt5); list.addFirst(nt4); for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } System.out.println("-------------获取元素-------------"); System.out.println(list.getFirst()); System.out.println(list.getLast()); System.out.println("-------------删除元素--------------"); System.out.println(list.removeFirst()); System.out.println(list.removeLast()); System.out.println("--------------删除元素后进行遍历-------------"); for (Object object : list) { System.out.println(object); } } } 输出结果 NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六] NewsTitle [id=1001, name=Java中还有这么神奇的事情, author=张三] NewsTitle [id=1002, name=合肥将变成一个没有传销的城市, author=李四] NewsTitle [id=1003, name=合肥比亚迪即将建成开厂, author=王五] NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七] -------------获取元素------------- NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六] NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七] -------------删除元素-------------- NewsTitle [id=1004, name=大湖名城，创新高低, author=赵六] NewsTitle [id=1005, name=大湖名城，创新高低, author=孙七] --------------删除元素后进行遍历------------- NewsTitle [id=1001, name=Java中还有这么神奇的事情, author=张三] NewsTitle [id=1002, name=合肥将变成一个没有传销的城市, author=李四] NewsTitle [id=1003, name=合肥比亚迪即将建成开厂, author=王五]
2.HashSet
2.1 HashSet类中的方法
-
boolean add(E e) int size() Iteratoriterator() 返回此集合中元素的迭代器,元素没有特定的顺序返回。 无get()方法 注： Iterator 接口中的方法 boolean hasNext() E next() 迭代器作用 是用来访问容器(用来保存元素的数据结构)中的元素,所以使用迭代器,我们就可以访问容器中里面的元素 -
HashSet是Set接口常用的实现类 ，set集合是无序的，所以不能使用get(下标)获取元素 如何遍历Set集合呢？ 方法一： 通过获取迭代器Iterator实现遍历 Collection接口的iterator()方法 Iterator接口的方法 boolean hasNext() 判断是否存在另一个可访问的元素 Object next() 返回要访问的下一个元素（因为这不是指向第一个元素，而是先指向的是空元素，所以访问的是下一个元素） 方法二： 增强for循环 -
例子 public class Test { public static void main(String[] args) { //准备数据：创建NewsTitle对象 NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三"); NewsTitle nt2 = new NewsTitle(1002, "合肥将变成一个没有传销的城市", "李四"); NewsTitle nt3 = new NewsTitle(1003, "合肥比亚迪即将建成开厂", "王五"); NewsTitle nt4 = new NewsTitle(1004, "大湖名城，创新高低", "赵六"); NewsTitle nt5 = new NewsTitle(1005, "大湖名城，创新高低", "孙七"); //准备容器 HashSet hs = new HashSet(); hs.add(nt1); hs.add(nt2); hs.add(nt3); hs.add(nt4); hs.add(nt5); hs.add(nt1); hs.add(nt1); System.out.println(hs.size());//5 因为他唯一，当重复了就不再往里加了 for (Object object : hs) { //因为set是无序的，所以每一次遍历都会输出的顺序不同（不考虑内存缓存问题） System.out.println(object); } System.out.println("-------------------"); //set集合是无序的，所以不能使用get(下标)获取元素 //hs.get(0); Iterator it = hs.iterator(); while(it.hasNext()){ Object obj =it.next(); NewsTitle nt = (NewsTitle)obj; System.out.println(nt); } } } -
特例 public class Demo { public static void main(String[] args) { Set set = new HashSet(); String s1 = new String("java"); String s2 = s1; String s3 = new String("JAVA"); NewsTitle nt1 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三"); NewsTitle nt2 = new NewsTitle(1001, "Java中还有这么神奇的事情", "张三"); set.add(nt1); set.add(nt2); System.out.println(set.size());//2 //new了两个不同的对象，回头搞一下String类和普通类 堆内存和栈内存存放方式 set.add(s1); set.add(s2); set.add(s3); System.out.println(set.size());//4 } }
3.HashMap
-
例子 public class Test { /* * 需求说明 * 学员应聘至外企工作，每个学员都会有一个英文名称，对应该学员对象。 * 请实现通过英文名称，获得该学员对象的详细信息 * 学员属性包括姓名以及性别 */ public static void main(String[] args) { //创建学生对象 Student stu1 = new Student("张三", "男"); //已经重写了toString()方法 Student stu2 = new Student("李四", "男"); Student stu3 = new Student("如花", "女"); //创建HashMap集合对象 HashMap hm = new HashMap(); //将学生对象添加到集合中 hm.put("jack", stu1); hm.put("tom", stu2); hm.put("rose", stu3); Object obj = hm.get("jack"); Student stu = (Student)obj; System.out.println("Jack对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getGender()); System.out.println("--------------------------"); //使用键值对的方式遍历输出所有学员的姓名和性别 Set set =hm.entrySet(); for(Object object:set){ Map.Entry me = (Map.Entry)object; //获取键值对的键 Object obj1 = me.getKey(); String key = (String)obj1; //获取键值对的值 Object obj2=me.getValue(); Student student = (Student)obj2; System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender()); } } } -
使用键值对方式遍历输出 Set set = (new HashMap).entrySet(); for(Object obj : set){ Map.Entry me =(Map.Entry)obj; Object obj1 =me.getKey(); //获取键值对的健（重写toString()方法，可以直接输出obj1） Object obj2 =me.getValue(); //获取键值对的值 } 例子 public class Test { /* * 需求说明 * 学员应聘至外企工作，每个学员都会有一个英文名称，对应该学员对象。 * 请实现通过英文名称，获得该学员对象的详细信息 * 学员属性包括姓名以及性别 */ public static void main(String[] args) { //创建学生对象 Student stu1 = new Student("张三", "男"); Student stu2 = new Student("李四", "男"); Student stu3 = new Student("如花", "女"); //创建HashMap集合对象 HashMap hm = new HashMap(); //将学生对象添加到集合中 hm.put("jack", stu1); hm.put("tom", stu2); hm.put("rose", stu3); Object obj = hm.get("jack"); Student stu = (Student)obj; System.out.println("Jack对应的学员信息为：姓名:"+stu.getName()+"，性别："+stu.getGender()); System.out.println("--------------------------"); //使用键值对的方式遍历输出所有学员的姓名和性别 Set set =hm.entrySet(); for(Object object:set){ Map.Entry me = (Map.Entry)object; //获取键值对的键 Object obj1 = me.getKey(); String key = (String)obj1; //获取键值对的值 Object obj2=me.getValue(); Student student = (Student)obj2; System.out.println(key+"对应的学员姓名："+student.getName()+"，性别为："+student.getGender()); } } }
3.1 HashMap常用方法（加上泛型）
-
public V put(K key, V value){} public V remove(Object key) {} public int size() {} public boolean containsKey(Object key) {} 在HashMap集合中，键值对的健若是有，则返回true public boolean containsValue(Object value) {} 在HashMap集合中，键值对的值若是有，则返回true public Collectionvalues() {} 返回的是获取值的集合 public Set keySet() {} 返回的是键值对的集合 public Set { public Iterator iterator() { return newKeyIterator(); } ......... } } （Abstract类实现了Set接口，所以重写了Set接口中的iterator()方法，但这个抽象类没有重写iterrator()方法，又被HashMap extends AbstractCollection implements Set { } 阿西吧.......... 看下面的例子，就是为了看懂下面两行代码 Set keys2 = hm.keySet(); Iterator it = keys2.iterator(); //疑惑就在为什么Set类型的接口可以调用iterator，原因就是HashMap绕了一圈实现了Set接口 例子 public class Test { public static void main(String[] args) { //准备键值对容器用来存储键值对 HashMap keys=hm.keySet(); for (String object : keys) { String key = object; String obj =hm.get(key); String value = obj; System.out.println(key+"---"+value); } System.out.println("--------------------"); //Collection values():获取值得集合 Collection coll = hm.values(); for (String object : coll) { String value = object; System.out.println(value); } System.out.println("--------------------"); //获取键的集合 Set keys2 = hm.keySet(); Iterator it = keys2.iterator(); while(it.hasNext()){ String key =it.next(); String value =hm.get(key); System.out.println(key+"---"+value); } System.out.println("--------------------"); //使用键值对的方式取出集合中的键值对 Set
3.2 泛型
-
将对象的类型作为参数，指定到其它类或者方法上，从而保证类型转换的安全性和稳定性
-
泛型集合可以约束集合内的元素类型 典型泛型集合ArryList、HashMap 和
3.3 加强for循环
-
public static void main(String[] args) { //arr int arr[]={1,2,3,4,5,6}; for(int i : arr){ System.out.println(i); } //string String s [] = {"hello","world","java"}; for(String i : s){ System.out.println(i); } //list Listlist = new ArrayList (); list.add("hello"); list.add("world"); list.add("java"); for(String i : list){ System.out.println(i); } //使用键值对的方式遍历输出所有学员的姓名和性别 HashMap
3.4 InstanceOf用法
-
instanceof关键字用于判断一个引用类型变量所指向的对象是否是一个类(或接口、抽象类、父类)的实例。 类型判断关键字。a instanceof b：判断a对象是不是b类型。这儿判断的时候，如果返回此语句已经返回ture，那么把b替换成b的父类型，也会是true 例子 class Animal{ String name; Animal(String name){ this.name = name; } } public class Dog extends Animal{ Dog(String name){ super(name); } public static void main(String[] msg){ Dog gg1 = new Dog("小白"); Animal gg2 = new Animal("旺财"); Animal gg3 = new Dog("狗蛋"); System.out.println(gg1 instanceof Dog); //True本类对象是本类的实例 System.out.println(gg1 instanceof Animal); //True子类对象是父类的实例 System.out.println(gg2 instanceof Dog); //false父类对象不是子类的实例 //System.out.println(Dog instanceof gg2); //编译错误，第一个关键字是引用类型，不可以是类 System.out.println(gg3 instanceof Dog); //True父类引用指向子类对象，该对象仍是子类的实例 } }
4.枚举
-
枚举是指由一组固定的常量组成的类型 public enum Genders { Male,Female } （注意下面gender的类型是枚举类型） public class Student{ private String name; private Genders gender; public String getName() { return name; } public void setName(String name) { this.name = name; } public Genders getGender() { return gender; } public void setGender(Genders gender) { this.gender = gender; } } （注意：stu.setGender(Genders.Male); 该方法里只能传在Gender中已经定义好的） public class StudentTest { public static void main(String[] args) { Student stu = new Student(); stu.setName("张三"); stu.setGender(Genders.Male); System.out.println(stu.getName()+"--"+stu.getGender()); System.out.println(Math.log10(10)); } }
5.Java API
5.1 包装类
-
包装类是把基本数据类型转换为对象，每个基本类型在java.lang包中都有一个相应的包装类 -
包装类的关系图
包装类的作用
提供了一系列使用的方法
集合不允许存放基本数据类型数据，存放数字时，要用包装类型
包装类的构造方法
所有包装类都可将与之对应的基本数据类型作为参数来构造它们的实例
public Type(type value){ //这是8大类型的构造方法，没有无参构造
this.value = value
}
例如
public Integer(int value) {
this.value = value;
}
除Character类外，其它包装可将一个字符串作为参数构造它们的实例
例如
Integer i = new Integer("123");
注意：
Boolean类型构造方法参数为String类型时，若该字符串内容为true（不考虑大小写），则该Boolean对象表示true，否则表示false
Integer i = new Integer("abc")，这个虽然编译不报错，但是运行时会抛出异常，numberformatexception表示数字格式化异常
Byte b = new Byte(1); 与 Short s = new Short((short) 1);必须要进行强制类型转换，因为，你传过去的是int类型的数据，构造函数接收的是小于int类型的数据
包装类型的常用方法
XXXValue():包装类型转换成基本类型
例子
Integer in = new Integer(25);
int i = in.intValue();
toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）
例子
String sex = Character.toString('男');
String str = Boolean.toString(true);
Integer inte = new Integer(100);
String str2 = inte.toString();
parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外,并且字符串里面的内容要能够转换为数字，否则会报异常）（字符串->基本类型）
byte num2 = Byte.parseByte("123");
System.out.println(num2);
boolean result = Boolean.parseBoolean("TruE");
System.out.println(result);
valueOf():所有包装类都有如下方法（基本类型->包装类） public static Type valueOf(type value)
byte byte2 = 10;
Byte byte3 = Byte.valueOf(byte2);
Byte byte4 = Byte.valueOf((byte)1);
Character cha = Character.valueOf('女');
除Character类外，其他包装类都有如下方法（字符串->包装类）public static Type valueOf(String s)
Byte byte5 = Byte.valueOf("123");
// Character.valueOf("a"); 报错
5.2 Collections与Collection
-
Collections是一个工具类。工具类是工具，就像Math，Arrays类一样，他是一种工具，集成了很多特定的功能。 比如排序，拷贝，替换，反转等等等功能。工具类不能被实例化。 工具类使用方式：类名.方法名() 总体来说：collection是接口 ， collections是工具类 Collections工具类的方法 sort():排序 binarySearch()：查找 max()\min():查找最大\最小值 实现一个类的对象之间比较大小，该类要实现Comparable接口，重写compareTo()方法，因为使用sort方法进入内部操作会调用到compartTo方法 ************************ 由于例子1中String类已经重写过compartTo方法，而例子2中自己定义的类需要自己实现compareTo方法 例子1（String类已经重写过compartTo方法） public class Demo01 { public static void main(String[] args) { ArrayListal = new ArrayList (); al.add("wseurfhu"); al.add("dsfsdf"); al.add("asdewre"); al.add("sdfsf"); al.add("afhth"); System.out.println("集合排序之前："); for (String string : al) { System.out.println(string); } //Collections.sort():对集合进行排序 Collections.sort(al); System.out.println("集合排序后："); for (String string : al) { System.out.println(string); } //int binarySearch(集合名,查找的数据):查找元素,返回查找元素所在的下标，如果查找不到元素，返回一个负值。 注意：使用该方法之前，对先对集合进行升序排序，否则不能保证查询结果的正确性 int index = Collections.binarySearch(al, "sdfsfgj"); System.out.println(index); //max()/min():求集合中的最大值最小值 String max = Collections.max(al); System.out.println(max); String min = Collections.min(al); System.out.println(min); Collections.reverse(al); System.out.println("集合元素反转之后："); Iterator it=al.iterator(); while(it.hasNext()){ String str = it.next(); System.out.println(str); } } } 例子2 （实现Comparable接口） public class Student implements Comparable{ private int number=0; //学号 private String name=""; //学生姓名 private String gender=""; //性别 public int getNumber(){ return number; } public void setNumber(int number){ this.number=number; } public String getName(){ return name; } public void setName(String name){ this.name=name; } public String getGender(){ return gender; } public void setGender(String gender){ this.gender=gender; } public int compareTo(Object obj){ Student student=(Student)obj; if(this.number==student.number){ return 0; //如果学号相同，那么两者就是相等的 }else if(this.number>student.getNumber()){ return 1; //如果这个学生的学号大于传入学生的学号 }else{ return -1; //如果这个学生的学号小于传入学生的学号 } } } import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; public class Test { public static void main(String[] args) { Student student1=new Student(); student1.setNumber(5); Student student2=new Student(); student2.setNumber(2); Student student3=new Student(); student3.setNumber(1); Student student4=new Student(); student4.setNumber(4); ArrayList list=new ArrayList (); list.add(student1); list.add(student2); list.add(student3); list.add(student4); System.out.println("-------排序前-------"); Iterator iterator=list.iterator(); while(iterator.hasNext()){ Student stu=iterator.next(); System.out.println(stu.getNumber()); } //使用Collections的sort方法对list进行排序 System.out.println("-------排序后-------"); Collections.sort(list); iterator=list.iterator(); while(iterator.hasNext()){ Student stu=iterator.next(); System.out.println(stu.getNumber()); } } }
5.3 拆箱和装箱
public class Demo04 {
public static void main(String[] args) {
// 装箱和拆箱
byte byte1 = 10;
Byte byte2 = new Byte(byte1);
Byte byte3 = Byte.valueOf(byte1);
// 装箱：直接将基本数据类型赋值给了包装类对象
Byte byte4 = byte1;
System.out.println(byte4);
Integer int1 = new Integer(20);
int int2 = int1.intValue();
// 拆箱：将包装类对象直接赋值给基本数据类型的变量
int int3 = int1;
System.out.println(int3);
// JDK1.5后，允许基本数据类型和包装类型进行混合数学运算
Integer num1 = new Integer(100);
int num2 = 1000;
int sum = num1 + num2;
System.out.println(sum);
Integer sum2 = num1 + num2;
System.out.println(sum2);
}
}
5.4 拆箱和装箱面试题
Integer i1 = 100; Integer i2 = 100; Integer i3 = 200; Integer i4 = 200; Integer i5 = new Integer(127); Integer i6 = new Integer(127); System.out.println(i5 == i6);//false System.out.println(i5.equals(i6));//true System.out.println(i1==i2);//true System.out.println(i3==i4);//false Float f1 = 20F; Float f2 = 20F; System.out.println(f1 == f2); //false Double i1 = 100.0; Double i2 = 100.0; Double i3 = 200.0; Double i4 = 200.0; System.out.println(i1==i2);//false System.out.println(i3==i4);//false System.out.println(i3.equals(i4)); //true //在Boolean中定义了2个静态成员属性 Boolean i1 = false; Boolean i2 = false; Boolean i3 =
