Java基础12-工具类;变长参数;IO
作业解析
取出整数的16进制表示形式 \u00ff
/**
* int2hex
* */
public static String int2hex(int i) {
String str = "0x";
char[] c = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
for(int j=28;j>=0;j=j-4) {
str = str + c[(i>>j)&0xf];
}
return str;
}
取出整数的8进制表示形式
/**
* int2oct
* */
public static String int2oct(int i) {
String str = "";
char[] c = {'0','1','2','3','4','5','6','7'};
for(int j=30;j>=0;j=j-3) {
str = str + c[(i>>j)&7];
}
return str;
}
使用韩语字符集实现字符串编解码
public static void main(String[] args) throws Exception {
//使用韩语字符集实现字符串编码
String str = "한국어";
System.out.println(str);//한국어 //utf-8编码解码
byte[] Byte = str.getBytes("utf-8");
System.out.println(new String(Byte,"utf-8"));//한국어 //GB2312编码解码
Byte = str.getBytes("GB2312");
System.out.println(new String(Byte,"GB2312"));//??? //EUC-KR编码解码
Byte = str.getBytes("EUC-KR");
System.out.println(new String(Byte,"EUC-KR"));//한국어
}
字符串倒序排列
public static void main(String[] args) throws Exception {
//字符串倒序排列
String str = "abcd1234";
byte[] Bytes = str.getBytes("utf-8");
byte[] Bytes2 = new byte[Bytes.length];
for(int i=Bytes.length-1;i>=0;i--) {
Bytes2[Bytes.length-1-i]=Bytes[i];
}
System.out.println(new String(Bytes2,"utf-8"));
}
练习自动拆箱和装箱
int i = 12;
Integer ii = i;
System.out.println(ii);//12
int j = ii;
System.out.println(j);//12
实现equals方法，比较四方面要素，Student{name height weight age}
public class Student {
private String name;
private int age;
private int height;
private int weight;
public Student(String name, int age, int height, int weight) {
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
}
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;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public boolean equals(Object obj) {
if(obj==this) {
return true;
}
if(obj==null) {
return false;
}
//精准匹配
if(obj.getClass()==Student.class) {
Student s = (Student)obj;
//判断姓名
boolean nameEqu = false;
if(s.getName()==null) {
if(this.getName()==null) {
nameEqu = true;
}
else {
nameEqu = false;
}
}
else {
nameEqu = s.getName().equals(this.getName());
} boolean ageEqu = false;
if(s.getAge()==this.getAge()) {
ageEqu = true;
}
boolean heightEqu = false;
if(s.getHeight()==this.getHeight()) {
heightEqu = true;
}
boolean weightEqu = false;
if(s.getWeight()==this.getWeight()) {
weightEqu = true;
}
return nameEqu && ageEqu && heightEqu && weightEqu;
}
return false;
}
}
Student s1 = new Student("s1", 10, 10, 10);
Student s2 = new Student(null, 10, 10, 10);
Student s3 = new Student(null, 10, 10, 10);
Student s4 = new Student("s1", 10, 10, 10); System.out.println(s1.equals(new Student("s2", 10, 10, 10)));//false
System.out.println(s1.equals(new Student("s1", 10, 10, 10)));//true System.out.println(s1==s1);//true
System.out.println(s1.equals(s1));//true System.out.println(s1==s4);//false
System.out.println(s1.equals(s4));//true System.out.println(s2==s3);//false
System.out.println(s2.equals(s3));//true System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//false System.out.println(s1.equals(null));//false
创建集合，存放10个person对象，5个Car对象，3个Bee对象，迭代集合，输出每个对象的name属性
public class Person {
private String name; public Person(String name) {
super();
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
} public class Car {
private String name;
private int no; public Car(String name, int no) {
super();
this.name = name;
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
} public class Bee {
private String name; public Bee(String name) {
super();
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
} public static void main(String[] args) {
List list = new ArrayList(); //存放人
for(int i=0;i<10;i++) {
list.add(new Person("p"+i));
}
//存放汽车
for(int i=0;i<5;i++) {
list.add(new Car("c"+i,i));
}
//存放蜜蜂
for(int i=0;i<3;i++) {
list.add(new Bee("b"+i));
} Iterator it = list.iterator();
while(it.hasNext()) {
Object obj = it.next();
//精准匹配
if(obj.getClass()==Person.class) {
Person p = (Person)obj;
System.out.println(p.getName());
}
if(obj.getClass()==Bee.class) {
Bee b = (Bee)obj;
System.out.println(b.getName());
}
if(obj.getClass()==Car.class) {
Car c = (Car)obj;
System.out.println(c.getName());
}
}
}
使用Map集合实现嵌套: 操场上六个年级，每个年级有10班，每个班有60人(String)
tom-x-y-n/**
* 使用Map集合实现嵌套: 操场上六个年级，每个年级有10班，每个班有60人(String)tom-x-y-n
* */
public class MapDemo { public static void main(String[] args) {
//定义年级
Map<Integer, Map<Integer, Map<Integer,String>>> grades = new HashMap<Integer, Map<Integer,Map<Integer,String>>>();
//定义班级
Map<Integer, Map<Integer,String>> classes = null;
for(int x=1;x<=6;x++) {
classes = new HashMap<Integer, Map<Integer,String>>();
grades.put(x, classes);
//定义名单
Map<Integer,String> names = null;
for(int y=1;y<=10;y++) {
names = new HashMap<Integer,String>();
classes.put(y, names);
for(int n=1;n<=60;n++) {
names.put(n, "tom-"+x+"-"+y+"-"+n);
System.out.println("tom-"+x+"-"+y+"-"+n);
}
}
} //迭代嵌套的Map集合
System.out.println("======使用KeySet==========");
outMapwithKey(grades); System.out.println("======使用EntrySet========");
outMapwithEntry(grades); System.out.println("=======使用迭代器==========");
outMapwithIterator(grades); } /**
* 使用key迭代
* */
private static void outMapwithKey(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
//取出年级key
Set<Integer> gradeSet = grades.keySet();
for(Integer gradeKey : gradeSet) {
Map<Integer, Map<Integer, String>> gradeValue = grades.get(gradeKey);
//取出班级key
Set<Integer> classSet = gradeValue.keySet();
for(Integer classKey: classSet) {
Map<Integer, String> classValue= gradeValue.get(classKey);
//取出名单key
Set<Integer> names= classValue.keySet();
for(Integer name: names) {
String s = classValue.get(name);
System.out.println(gradeKey+"-"+classKey+"-"+name+":"+s);
}
}
}
}
/**
* 使用条目迭代
* */
private static void outMapwithEntry(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
//取出年级条目：年级id ------> 班级集合
Set<Entry<Integer,Map<Integer, Map<Integer, String>>>> gradeEntries = grades.entrySet();
for(Entry<Integer,Map<Integer, Map<Integer, String>>> gradeEntry: gradeEntries) {
//依次取出每个条目的键:年级id，每个条目的值：班级条目集合
Integer gradekey = gradeEntry.getKey();
Map<Integer, Map<Integer, String>> classes = gradeEntry.getValue(); //取出班级条目：班级id ------> 名单集合
Set<Entry<Integer, Map<Integer, String>>> classEntries = classes.entrySet();
for(Entry<Integer, Map<Integer, String>> classEntry : classEntries) {
//依次取出每个条目的键:班级id，每个条目的值：名单条目集合
Integer classKey = classEntry.getKey();
Map<Integer, String> classValue= classEntry.getValue();
System.out.println(gradekey+"年"+classKey+"班"+":");
//取出名单条目：学生id ----> 学生姓名
Set<Entry<Integer, String>> namesEntries = classValue.entrySet();
for(Entry<Integer, String> namesEntry : namesEntries) {
Integer namesKey = namesEntry.getKey();
String namesValue = namesEntry.getValue();
System.out.println(gradekey+"-"+classKey+"-"+namesKey+":"+namesValue);
}
}
}
} /**
* 使用迭代器迭代
* */
private static void outMapwithIterator(Map<Integer, Map<Integer, Map<Integer, String>>> grades) {
//取出年级条目：年级id ------> 班级集合
Set<Entry<Integer,Map<Integer, Map<Integer, String>>>> gradeEntries = grades.entrySet();
//一级迭代器，迭代年级条目
Iterator<Entry<Integer,Map<Integer, Map<Integer, String>>>> it = gradeEntries.iterator();
while(it.hasNext()) {
//利用一级迭代器依次取出年级id，班级集合
Entry<Integer,Map<Integer, Map<Integer, String>>> gradeEntry= it.next();
Integer gradeKey = gradeEntry.getKey();
Map<Integer, Map<Integer, String>> gradeValue = gradeEntry.getValue(); //二级迭代器，迭代班级条目
Set<Entry<Integer, Map<Integer, String>>> classEntries = gradeValue.entrySet();
Iterator<Entry<Integer, Map<Integer, String>>> it2 = classEntries.iterator();
while(it2.hasNext()) {
//利用二级迭代器依次取出班级id，名单集合
Entry<Integer, Map<Integer, String>> classEntry= it2.next();
Integer classKey = classEntry.getKey();
Map<Integer, String> classValue = classEntry.getValue(); //三级迭代器，迭代学生名单
Set<Entry<Integer, String>> nameEntries = classValue.entrySet();
Iterator<Entry<Integer, String>> it3 = nameEntries.iterator();
while(it3.hasNext()) {
//利用三级迭代器依次取出学生id，姓名
Entry<Integer, String> nameEntry = it3.next();
Integer nameKey = nameEntry.getKey();
String nameValue = nameEntry.getValue();
System.out.println(gradeKey+"-"+classKey+"-"+nameKey+":"+nameValue);
}
}
}
}
}
定义罪犯Criminal类，height(身高)/weight(体重)/blood(血型)/home(籍贯)属性。
重写hashcode和equals，使用四个属性的组合进行实现。
创建HashSet集合，里面存放20个Criminal对象，其中O型血2人，A型血3人，B型血4人，AB型血1人，其余血型不详。
注意:hashcode()方法实现时，要求身高、体重、和血型三个属性合成一个数字，实现两两比较的高效算法。创建HashMap, Person为key, Dog 为value。
存放100元素，遍历map集合，两种方式：EntrySet + KeySetpublic class Person {
private String name; public Person(String name) {
super();
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
if(name!=null) {
return name.hashCode();
}
else {
return 0;
}
}
@Override
public boolean equals(Object obj) {
if(obj==null) {
return false;
}
if(obj==this) {
return true;
}
if(obj.getClass()==Person.class) {
Person p = (Person)obj;
if(p.getName()==null) {
if(this.getName()==null) {
return true;
}
else {
return false;
}
}
else {
return p.getName().equals(this.getName());
}
}
return false;
}
@Override
public String toString() {
return name;
}
} public class Dog {
private String name;
private String color;
private String categraory;
public Dog(String name, String color, String categraory) {
super();
this.name = name;
this.color = color;
this.categraory = categraory;
}
@Override
public String toString() {
return name+"-"+color+"-"+categraory;
}
} /**
* 创建HashMap, Person为key, Dog 为value。存放100元素，遍历map集合，两种方式：EntrySet + KeySet
* */
public static void main(String[] args) {
Map<Person,Dog> map = new HashMap<Person, Dog>();
map.put(new Person("p1"), new Dog("d1","black","Jing8"));
map.put(new Person("p1"), new Dog("d1","black","Jing8"));
map.put(new Person(null), new Dog("d1","black","Jing8"));
map.put(new Person(null), new Dog("d1","black","Jing8"));
map.put(null, new Dog("d1","black","Jing8"));
map.put(null, new Dog("d1","black","Jing8"));
System.out.println(map.size());//没有重写hashcode()和equals()方法之前，结果为5;
System.out.println(map.size());//重写 equals方法之后，结果仍为5;
System.out.println(map.size());//重写hashcode和equals方法后，结果为3 //存放100个条目
map.clear();
for(int i=0;i<100;i++) {
map.put(new Person("p"+i), new Dog("d"+i,"black","Jing8"));
} //使用EntrySet遍历
Set<Entry<Person,Dog>> entries = map.entrySet();
for(Entry<Person,Dog> entry : entries) {
Person key = entry.getKey();
Dog value = entry.getValue();
System.out.println(key+":"+value);
} //使用keySet遍历
System.out.println("=====================");
Set<Person> keys = map.keySet();
for(Person key: keys) {
Dog value = map.get(key);
System.out.println(key+":"+value);
}
}
工具类，变长参数
Collections
public class Person implements Comparable<Person> {
private String name=""; public Person(String name) {
super();
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
} @Override
public int compareTo(Person o) {
return this.name.compareTo(o.getName());
}
} public class CollectionToolDemo { public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("a");
list.add("abc");
list.add("123");
list.add("中国");
list.add("法国人");
list.add(""); outEle(list);//a,abc,123,中国,法国人,, //使用工具类排序
Collections.sort(list);
outEle(list);//,123,a,abc,中国,法国人, //取出最大值
String max = Collections.max(list);
System.out.println("max="+max);//max=法国人 //取出最小值
String min = Collections.min(list);
System.out.println("min="+min);//min= //反序（非反向排序）
Collections.reverse(list);
outEle(list);//法国人,中国,abc,a,123,, //交换元素位置
Collections.swap(list, 1, 3);
outEle(list);//法国人,a,abc,中国,123,, List<Person> list2 = new ArrayList<Person>();
list2.add(new Person("熊大"));
list2.add(new Person("光头强"));
list2.add(new Person("熊二")); outEle(list2);//熊大,光头强,熊二, Collections.sort(list2);//需要实现Comparable接口才可以排序
outEle(list2);//光头强,熊二,熊大, }
/**
* 输出集合元素
* */
public static void outEle(List<? extends Object> list) {
for(Object s: list) {
System.out.print(s+",");
}
System.out.println();
}
}
Arrays
public static void main(String[] args) {
int[] a = new int[]{1,3,5,7};
int[] a2 = copyArr(a);
System.out.println(a2.length);//4
int[] a3 = Arrays.copyOf(a, 2);
System.out.println(a3); //二分法查找
System.out.println(Arrays.binarySearch(a, 7));//3
System.out.println(Arrays.binarySearch(a, 0,3,7));//-4 //转数组为列表
List<Integer> list = Arrays.asList(1,2,3,4);
System.out.println(list.size());
}
public static int[] copyArr(int[] arr) {
//健壮性
if(arr==null || arr.length==0) {
return arr;
}
int[] arr2 = new int[arr.length];
for(int i=0;i<arr.length;i++) {
arr2[i] = arr[i];
}
return arr2;
}
变长参数
变长参数必须是方法的最后一个参数
public void addTel(String s1, String... str); //ok
public void addTel(String... str,String s1); //errorpublic static void main(String[] args) {
outArr("1","2","3","4","5");
}
//变长参数只能有一个，且必须是最后一位形参
public static void outArr(String...str) {
for(String s:str) {
System.out.println(s);
}
}
集合内容回顾
list
- ArrayList //不安全
- LinkedList // 不安全
- Vector // 线程安全
Set
- Hashset, hashmap
- TreeSet: 有序，Comparable
排序实现方式：
1）实现Comparable接口, interface Comparable{int compare}
2）Comparator，对比器
Map
HashMap: key(键) - value(值) KV====Entry
HashTable: 线程安全
IO
分类
- 按流向：
输入流 Input
输出流 Output - 按类型：
字节型: InputStream, OutputStream
字符型: Reader, Writer
- 按流向：
编译时异常：需要在代码中对异常进行声明或捕获
FileWriter
public static void main(String[] args) {
FileWriter fw = null;
try {
fw = new FileWriter("d:\\fileWriter.txt");;
fw.write("Hello, FileWriter");
System.out.println("over");
} catch (IOException e) {
e.printStackTrace();
}
finally {
//释放资源
try {
if(fw!=null) {
fw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
new FileWriter(String path);
Writer(String str);
写入字符数据到流中flush()
清理流，将流中的数据写入目标设备上close()
关闭流，隐含了flush操作。流在close之后，无法再写入数据，重复关闭不会导致问题
FileReader
不支持reset(),不支持mark(),支持skippublic static void main(String[] args) throws Exception {
FileReader fr = new FileReader("d:\\fileWriter.txt");
int i = 0;
while((i=fr.read())!=-1) {
System.out.print((char)i);
}
fr.close(); //do...while
System.out.println("================");
i=-1;
fr = new FileReader("d:\\fileWriter.txt");
do {
i = fr.read();
if(i!=-1) {
System.out.print((char)i);
}
}while(i!=-1);
fr.close(); //使用char[]缓冲区读取文件
System.out.println("============");
fr = new FileReader("d:\\fileWriter.txt");
//fr.reset();//不支持
//fr.markSupported();//false
char[] buf = new char[10];
int len = 0;
while((len=fr.read(buf))!=-1) {
System.out.print(new String(buf,0,len));
}
fr.close();
}
作业
描述HashMap内部实现原理
List Set Map区别
描述HashSet和HashMap的区别
编程实现文本文件的复制。合理设计程序，得到缓冲区的大小的高效区间。
提示缓冲区设置1k开始，不超过10M。使用FileWriter，将1-1000000写入到文本中
变长参数 + 增强for循环
Java基础12-工具类;变长参数;IO的更多相关文章
- Java基础-DButils工具类（QueryRunner）详解
Java基础-DButils工具类(QueryRunner)详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 如果只使用JDBC进行开发,我们会发现冗余代码过多,为了简化JDBC ...
- Java基础-常用工具类（一）
object类 Object 类是所有类的的父类,如果一个类没有明确使用EXPENTS关键字明确标识继承另外一个类,那么这个类默认继承object类,oject类中的方法适合所有子类 1)toStri ...
- JAVA基础——Arrays工具类十大常用方法
Arrays工具类十大常用方法 原文链接:http://blog.csdn.net/renfufei/article/details/16829457 0. 声明数组 String[] aArray ...
- java 基础 ----- Arrays 工具类
----- Arrays 工具类是一个比较方便的类 常用的方法 也可以通过jdk文档进行查看 右侧有偶 对一些比较常用的方法进行演示 直接放在main方法中进行测试 ---- equ ...
- Java基础-常用工具类（二）
Scanner 类 java.util.Scanner 是 Java5 的新特征,我们可以通过 Scanner 类来获取用户的输入. 通过 Scanner 类的 next() 与 nextLine() ...
- java基础之 工具类
一.StringUtils StringUtils.isEmpty(null) && StringUtils.isEmpty(""); // true String ...
- Java语法糖初探（三）--变长参数
变长参数概念 在Java5 中提供了变长参数(varargs),也就是在方法定义中可以使用个数不确定的参数,对于同一方法可以使用不同个数的参数调用.形如 function(T …args).但是需要明 ...
- java常量和变量的定义规则，变长参数的使用
首先是定义的一般规则,类名首字母全部大写,常量全部大写用下划线分隔,变量用驼峰形式.注意使用long赋值用L时不能写小写的L要写大写的,不然会和数字“1”傻傻分不清. 下面是举例: public cl ...
- 介绍C++11标准的变长参数模板
目前大部分主流编译器的最新版本均支持了C++11标准(官方名为ISO/IEC14882:2011)大部分的语法特性,其中比较难理解的新语法特性可能要属变长参数模板(variadic template) ...
随机推荐
- WordPress慢的八种解决方法（用排查法解决）
WordPress的打开速度慢会影响到用户体验和关键词的稳定排名,WordPress为什么加载慢呢?其实很简单的,就是WordPress水土不服,用WordPress的大家都知道,WordPress是 ...
- Python_range
range 当作定义的数字范围列表. 满足顾头不顾腚,可以加步长,与for循环结合使用. 一般使用 for i in range(0, 101): print(i) 结果: #[0,1,2,3,... ...
- 【调试工具】tcpdump
[tcpdump]https://linux.cn/article-10191-1.html
- 使用elementUI滚动条之横向滚动
用过elementUI组件应该会知道它内置一个滚动效果,官网对此组件没有相关文档,也是细心网友发现的. <el-scrollbar></el-scrollbar> 将会出现滚动 ...
- ajax基本原理与案例
一.什么是Ajax AJAX即“Asynchronous Javascript And XML”( 异步 JavaScript和XML),AJAX不是一种新的编程语言,而是一种用于创建更好更快以及交互 ...
- 最长公共子序列（POJ1458)
给出两个字符串,求出这样的一个最长的公共子序列的长度:子序列中的每个字符都能在两个原串中找到,而且每个字符的先后顺序和原串中的先后顺序一致. Sample Input: abcfbc abfcabpr ...
- 树莓派3B+(二)
一.安装SSH工具 这里用的是putty,下载下来是一个exe文件,点开就能用. 下载地址:https://www.chiark.greenend.org.uk/~sgtatham/putty/lat ...
- python测试工程师高端基础面试题整理
面试总括篇 技术技能 开发语言:python 数据库:mysql 操作系统;linux 网络协议基础 测试技能:自动化(UIselenium+接口)+性能 业务知识 测试工程师执业规划 初级--> ...
- <TCP/IP原理> (四) IP编址
1.IP地址的基本概念:作用.结构.类型 2.特殊地址:作用.特征 网络地址.广播地址(直接.受限) 0.0.0.0 环回地址 3.单播.多播.广播地址:特征 4.专用地址:作用.范围 5.计算和应用 ...
- 关于Aop切面中的@Before @Around等操作顺序的说明
[转]http://www.cnblogs.com/softidea/p/6123307.html 话不多说,直接上代码: package com.cdms.aop.aspectImpl; impor ...