Java基础语法(中)
数学类
数学类提供的一些常用方法:
- pow(x,y) 计算x的y次幂
- abs(x). 计算x的绝对值
- log(x). 计算以e为底x的对数, e是啥, 我只能告诉你e被称为欧拉数….
- max(x,y) 返回x, y中大的那个数
- min(x, y) 返回x,y中小的那个数
- round(x) x四舍五入
- sqrt(x) 计算x的开平方. 根号下x
数学类的其他方法传送门:https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html
package com.dylan.math;
public class Test {
public static void main(String[] args) {
System.out.println(Math.pow(3, 3)); // 3的3次方
System.out.println(Math.abs(-12)); // 12
System.out.println(Math.log(2)); // 以e为底, 2的对数
System.out.println(Math.max(12, 33)); // 求大数 33
System.out.println(Math.min(55, 33)); // 求小数 33
System.out.println(Math.round(3.56789)); // 4 四舍五入
System.out.println(Math.sqrt(3)); // 根号9 1.732
}
} - 求解二元方程
package com.dylan.math;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入a:");
double a = sc.nextInt();
System.out.println("请输入b:");
double b = sc.nextInt();
System.out.println("请输入c:");
double c = sc.nextInt();
// 先判断b*b-4*a*c是否大于0 . 不大于0无解
double dt = b*b - 4*a*c;
if (dt < 0){
System.out.println("此方程无解");
} else if(dt == 0){
System.out.println("此方程有一个解");
double x = -b/(2*a);
System.out.println("x = " + x);
} else {
System.out.println("此方程有两个解");
double x1 = (-b+Math.sqrt(dt)) / (2*a);
double x2 = (-b-Math.sqrt(dt)) / (2*a);
System.out.println("x1 = "+x1 + ", x2 = "+x2);
}
}
} Random类
import java.util.Random;
public class Test {
public static void main(String[] args) {
Random r = new Random(13); // 传入种子13
// 随机产生10个[0, 100)之间的整数
for(int i=0;i<1;i++){
System.out.println(r.nextInt(100)); // 92
System.out.println(r.nextInt()); // 1412442200
System.out.println(r.nextDouble()); // 0.44461356134079055
System.out.println(r.nextFloat()); // 0.051283896
System.out.println(r.nextBoolean()); //true
}
}
} 基本数据类型包装类
| 基本类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Charactor |
| boolean | Boolean |
除了int和char以外都是基本数据类型首字母大写. 很好记.
打包与解包
在java里, 基本数据类型是可以和包装类型进行无缝转换的.
Integer i = 1; // 自动打包成Integer对象 int b = i; // 自动解包成int类型
基本数据类型包装类存在的意义:
- 让基本数据类型有了面向对象的特征.
- 可以把字符串转化成各种基本数据类型
基本数据类型转换
public class Test {
public static void main(String[] args) {
String a = "1";
String b = "1";
System.out.println(a+b); // 11 滑天下之大稽
// 把字符串转化成int
int c = Integer.parseInt(a);
int d = Integer.parseInt(b);
System.out.println(c + d); // 2 没毛病老铁
//转化成double试试
double e = Double.parseDouble(a);
double f = Double.parseDouble(b);
System.out.println(e+f);
}
} 规律: 字符串->基本数据类型
基本数据类型包装类.parse基本数据类型()
Integer.parseInt();
Double.parseDouble();
Long.parseLong();
Boolean.parseBoolean();
都一样
~
Integer in = new Integer(20); System.out.println(in.toString()) // 将20转化为字符串"20"
Date类型
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date1 = new Date(); // 获取当前时间对象
Date date2 = new Date(9444442323L); // 获取1970年1月1日以来9444442323ms后的时间
System.out.println(date1);
System.out.println(date2);
}
}
// Wed Jul 24 14:44:28 CST 2019
// Mon Apr 20 15:27:22 CST 1970 Calendar类
import java.util.Calendar;
public class Test {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH) + 1;
int date = calendar.get(Calendar.DATE);
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
System.out.println("当前时间为:"+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
}
}
// 当前时间为:2019年7月24日2时50分58秒 import java.util.Calendar;
public class Test {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
calendar.set(2019,7,1);
calendar.add(Calendar.DATE, 100);
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH + 1);
int date = calendar.get(Calendar.DATE);
System.out.println("100天后是"+year+"年"+month+"月"+date+"日");
}
}
// 100天后是2019年45月9日 DateFormat类
import java.util.Calendar;
import java.util.Date;
import java.text.DateFormat;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// Full格式
DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
// Long模式
DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
// mediunm格式日期时间对象
DateFormat mediumFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
// short格式日期时间对象
DateFormat shortFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
System.out.println(fullFormat.format(date));
System.out.println(longFormat.format(date));
System.out.println(mediumFormat.format(date));
System.out.println(shortFormat.format(date));
}
}
// 2019年7月24日星期三
// 2019年7月24日
// 2019年7月24日 下午3:00:52
// 2019/7/24 下午3:00 DecimalFormat类
我想保留小数点后两位怎么办? 就用这个叫DecimalFormat.
import java.text.DecimalFormat;
public class TestNumberFormat {
public static void main(String[] args) {
double d = 10/3.0;
System.out.println(d);
DecimalFormat df = new DecimalFormat(".00"); // 保留小数点后两位
String s = df.format(d);
System.out.println(s); // 3.33
}
} 这一堆格式中, 我们只需要关注三个
0: 数字
#: 数字
. : 小数点
.00 和.## 是一样的.
字符串详解
String s1 = "胡辣汤";
String s2 = new String("狗不理"); public class TestString {
public static void main(String[] args) {
String s = "今天特别想吃哈密瓜";
//charAt(int) 获取到字符串中某个位置的字符. 从0开始数
System.out.println(s.charAt(0)); // 今
System.out.println(s.charAt(4)); // 想
// concat(String) 字符串拼接. 和+是一样的
System.out.println(s.concat("伊丽莎白")); // 今天特别想吃哈密瓜伊丽莎白
//今天特别想吃哈密瓜 深坑: 字符串是不可变的. 不论做什么操作, 原来的字符串不会发生改变, 每次操作都是返回一个新字符串
System.out.println(s);
// contains(String) 判断字符串中是否包含xxx
System.out.println(s.contains("明天")); // false
System.out.println(s.contains("哈密瓜")); // true
// startswith(String) 判断字符串是否以xxxx开头
// endswith(String) 判断字符串是否以xxxx结尾
System.out.println(s.startsWith("今天")); // true
System.out.println(s.endsWith("哈密瓜")); // true
// equals(String) 判断两个字符串内容是否一致
// equalsIgnoreCase(String) 判断两个字符串内容是否一致(忽略大小写)
System.out.println("abc".equals("abc")); // true
System.out.println("abc".equalsIgnoreCase("ABC")); // true
// indexOf(String) 根据给定的字符串计算该字符串出现的位置 -> 从前向后
// lastIndexOf(String) 根据给定的字符串计算该字符串出现的位置-> 从后向前
System.out.println(s.indexOf("特别")); // 2
System.out.println(s.lastIndexOf("哈密瓜")); // 6
// isEmpty() 判断字符串是否是空字符串
System.out.println("".isEmpty()); // true
System.out.println(" ".isEmpty()); // false
// length() 字符串的长度 -> 有多少个字符组成
System.out.println(s.length()); // 9
// replace(String, String) 把xxx替换成xxx
String s1 = s.replace("今天", "昨天");
System.out.println(s); // 今天特别想吃哈密瓜 没变~~~~ 字符串不可变哦
System.out.println(s1); // 昨天特别想吃哈密瓜 获得的新字符串
// replaceFirst(String, String); 替换第一个
String s2 = s.replace("天", "日");
System.out.println(s2); // 今日特别想吃哈密瓜
// split(String) 字符串切割
String[] strs = s.split("想吃"); // 使用"想吃"进行字符串切割. 切割的结果放在字符串数组中
System.out.println(strs[0]); // 今天特别
System.out.println(strs[1]); // 哈密瓜
// subString(int, int) 字符串截取. 从xxx截取到xxx
String s3 = s.substring(2, 4);
System.out.println(s3); // 特别
// toUpperCase(); 转化成大写
// toLowerCase(); 转化成小写
String s4 = "abcDefGhIJKLMN";
System.out.println(s4.toUpperCase());
System.out.println(s4.toLowerCase());
// trim(); 去掉左右两端的空格
String s5 = " 哇哈哈哈哈 ";
System.out.println(s5.trim()); //哇哈哈哈哈
}
} StringBuilder和StringBuffer
“我的妈呀”+”你的妈呀”+”谁的妈呀”+”怎么这么卡”. 在老的JDK中 每次相加都会产生一个新的字符串, 非常的浪费内存资源, 但是在新版本中, JDK对这里进行了优化. 每次+都是执行用的StringBuilder中的字符串拼接方法. 为什么呢? 因为StringBuilder是可以改变的字符串. 都在原来的基础上进行操作. 所以不会产生内存浪费. 接下来我们来看看这个叫StringBuilder的东西.
StringBuilder: 可变的字符串
用法:
public class TestStringBuilder {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder(); // 空的字符串.
StringBuilder sb2 = new StringBuilder("王二麻子的麻子特别特别麻"); // 也可以给出具体的字符串. 都OK
sb2.append(", 李二麻子的麻子就不是特别麻"); // 在后面追加
System.out.println(sb2); // 王二麻子的麻子特别特别麻, 李二麻子的麻子就不是特别麻
sb2.append(123); //可以追加任何数据类型
sb2.insert(3, "插入");// 还可以在中间插入
System.out.println(sb2); // 王二麻插入子的麻子特别特别麻, 李二麻子的麻子就不是特别麻123
String s = sb2.toString(); // 转化回正常的普通字符串
System.out.println(s);
}
} 关于StringBuilder, 咱们就说这么多. 足够大家在平时使用了
StringBuffer和StringBuilder基本上一模一样. 区别是StringBuffer线程安全. StringBuilder线程不安全. 等到后面我们学到线程的时候, 在给大家说他俩的区别. 就目前而言. 你可以认为没区别..
容器
- List
- Set
- Map
List
List和咱们以前学过的数组其实差不多. 不过List的优势是可以随意扩容. 多少数据都能装的下
List也有两个常用的实现类: ArrayList(重要), LinkedList.
先看重要的:
import java.util.ArrayList;
import java.util.List;
public class TestList {
public static void main(String[] args) {
ArrayList lst = new ArrayList();
lst.add("狂战士");
lst.add("狂战士");
lst.add("剑圣");
lst.add(123);
lst.add("狱血魔神");
lst.add("红豆");
System.out.println(lst); // [狂战士, 狂战士, 剑圣, 123, 狱血魔神, 红豆]
}
} 结论: 没有去掉重复. 没有打乱顺序.
再看这个不是特别重要的
import java.util.LinkedList;
import java.util.List;
public class TestList {
public static void main(String[] args) {
LinkedList lst = new LinkedList();
lst.add("美团外卖");
lst.add("饿了么");
lst.add("百度外卖");
lst.add("我不吃");
lst.add("外卖");
lst.add(2,"饭堂");
lst.addFirst("北门");
lst.addLast("南门");
System.out.println(lst); // [美团外卖, 饿了么, 百度外卖, 我不吃, 外卖]
}
} List集合中定义的方法
| add(int index, Object element) | 作用 |
|---|---|
| void add(int index, Object element) | 在Index处添加元素 |
| boolean addAll(int index, Collection c) | 将集合c所包含的元素全部插入到List集合的index处 |
| Object get(int index) | 查看第i个元素 |
| Object set(int index, Object element) | 在index处替换元素 |
| int size() | 查看列表中的数据个数 |
| boolean isEmpty() | 判断是否是空列表 |
| int indexOf(Object element) | 查看元素在列表中的位置 |
| int lastIndexOf(Object element) | 查看元素在列表中最后一次出现的位置 |
| boolean contains(Object element) | 判断列表中是否包含某元素 |
| List subList(int start, int end) | 截取子串 |
| Object remove(int index) | 删除索引为index的元素 |
| Object remove(Object element) | 删除某元素 |
import java.util.ArrayList;
import java.util.List;
public class TestList {
public static void main(String[] args) {
List lst = new ArrayList();
lst.add("美团外卖");
lst.add("饿了么");
lst.add("百度外卖");
lst.add("我不吃");
lst.add("外卖");
System.out.println(lst); // [美团外卖, 饿了么, 百度外卖, 我不吃, 外卖]
System.out.println(lst.get(0)); // 查询第0个元素
System.out.println(lst.get(2)); // 查询第2个元素
System.out.println(lst.size()); // 列表中元素的个数
// 遍历出列表中所有的数据
for(int i = 0 ; i < lst.size(); i++){
System.out.println(lst.get(i));
}
// 判断列表是否是空列表
System.out.println(lst.isEmpty()); // false
//查看"我不吃"元素在列表中的位置
System.out.println(lst.indexOf("我不吃")); // 3
//查看最后一个"百度外卖"在列表中的位置
System.out.println(lst.lastIndexOf("百度外卖")); // 2
//判断是否包含饿了么
System.out.println(lst.contains("饿了么")); // true
//列表的截取, 从1截取到3 [1,3)区间
System.out.println(lst.subList(1, 3)); // [饿了么, 百度外卖]
System.out.println(lst.toArray()); // 转化成数组
lst.remove("外卖"); // 删除"外卖"
lst.remove(2); // 删除索引为2的元素
}
} LinkedList中定义的方法
| 方法名 | 作用 |
|---|---|
| void add(int index, Object element) | 某位置插入元素 |
| void addFirst(Object o) | 将元素插入开头 |
| void addLast(Object o) | 将元素插入末尾 |
| Object getFirst() | 返回第一个元素 |
| Object getLast() | 返回最后一个元素 |
| Object removeFirst() | 移除并返回第一个元素 |
| Object removeLast() | 移除并返回最后一个元素 |
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
System.out.println(link.toString());
link.add(2,"Student");
link.addFirst("First");
link.addLast("Last");
System.out.println(link);
System.out.println(link.getFirst());
System.out.println(link.getLast());
link.remove(3);
link.removeFirst();
System.out.println(link);
}
}
Iterator接口
| 方法名 | 作用 |
|---|---|
| boolean hasNext() | 判断是否存在下一个元素 |
| Object next() | 获取下一个元素 |
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
Iterator it = link.iterator();
while (it.hasNext())
{
Object obj = it.next();
System.out.println(obj);
}
/*
foreach(Object obj:link)
{
System.out.println(obj);
}
*/
}
} foreach遍历 (不能修改)
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
Iterator it = link.iterator();
foreach(Object obj:link)
{
System.out.println(obj);
}
}
} 元素遍历删除
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class Test {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
Iterator it = link.iterator();
while(it.hasnext())
{
if("stu3".equals(obj))
{
it.remove();
// 不可以用link.remove(obj)
}
}
}
} ListIterator迭代器
Iterator迭代器提供了 hasNext() 方法和 next() 方法
其为Iterator的子类, 在父类基础上增加了一些特有的方法
| 方法名 | 作用 |
|---|---|
| void add(Object o) | 插入元素 |
| boolean hasPrevious() | 逆向遍历 |
| Object previous() | 返回列表中的前一个元素 |
| void remove() | 从列表中移除由next或previous返回的最后一个元素 |
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class Test {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.add("stu1");
link.add("stu2");
link.add("stu3");
link.add("stu4");
ListIterator it = link.listIterator(link.size());
while(it.hasPrevious())
{
Object obj = it.previous();
System.out.println(obj);
}
}
}
// stu4
// stu3
// stu2
// stu1 set
HashSet瞎摆->存储的速度快,TreeSet按顺序摆->存储的时候帮你排序, 存储的速度就慢.
HashSet
当向
HashSet集合中添加一个对象时, 首先会调用该对象的 hashCode()方法来确定元素的存储位置, 然后调用equals()方法来确保该位置没有重复元素
import java.util.HashSet;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
HashSet s = new HashSet();
s.add("a");
s.add("b");
s.add("c");
s.add("c");
s.add("d");
Iterator it = s.iterator();
while(it.hasNext())
{
Object data = it.next();
System.out.println(data);
}
}
} 重写 hashCode() 和 equals() 方法
public class Student {
String id;
String name;
public Student(String id, String name)
{
this.id = id;
this.name = name;
}
// 重写toString方法
public String toString()
{
return id + ":" + name;
}
// 重写hashCode方法
public int hashCode()
{
return id.hashCode();
}
// 重写equals方法
public boolean equals(Object obj)
{
if(this == obj)
{
return true;
}
if(!(obj instanceof Student))
{
return false;
}
Student stu = (Student) obj;
boolean b = this.id.equals(stu.id);
return b;
}
} import java.util.HashSet;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
HashSet hs = new HashSet();
Student s1 = new Student("1", "Jack");
Student s2 = new Student("2", "Rose");
Student s3 = new Student("2", "Rose");
hs.add(s1);
hs.add(s2);
hs.add(s3);
System.out.println(hs);
}
}
// [1:Jack, 2:Rose] TreeSet
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet s = new TreeSet();
s.add("a");
s.add("b");
s.add("c");
s.add("c");
s.add("d");
Iterator it = s.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
} 实现Comparable接口
import java.util.*;
public class Student implements Comparable {
String name;
int age;
public Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String toString()
{
return name + ":" + age;
}
// 先按照年龄升序排列, 再按姓名升序排列
public int compareTo(Object obj)
{
Student s = (Student)obj;
if(this.age - s.age > 0)
{
return 1;
}
if(this.age - s.age == 0)
{
return this.name.compareTo(s.name); // 调用String中的compareTo方法
}
return -1;
}
} import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(new Student("Jack", 19));
ts.add(new Student("Rose", 18));
ts.add(new Student("Tom", 19));
ts.add(new Student("Rose", 18));
ts.add(new Student("Amy", 18));
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
// Amy:18
// Rose:18
// Jack:19
// Tom:19 自定义比较器
import java.util.Comparator;
public class MyComparator implements Comparator {
public int compare(Object obj1, Object obj2)
{
String s1 = (String)obj1;
String s2 = (String)obj2;
return s1.length() - s2.length();
}
}
import java.util.Iterator;
import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new MyComparator());
ts.add("Jack");
ts.add("Amy");
ts.add("Helena");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
// Amy
// Jack
// Helena Set的常用方法:
- add() 添加元素
- remove() 删除元素
- size() 集合中元素的个数
- contains() 判断是否包含了xxxx
import java.util.HashSet;
import java.util.Set;
public class TestSet2 {
public static void main(String[] args) {
Set s = new HashSet();
s.add("饮血剑");
s.add("绿叉");
s.add("无尽之刃");
System.out.println(s); //[绿叉, 无尽之刃, 饮血剑]
s.remove("绿叉"); // 删除绿叉
System.out.println(s.size()); // 2
System.out.println(s.contains("无尽之刃")); // true
}
} Map
Map常见的实现类也有两个, 一个是HashMap(常用), 另一个TreeMap.
map常用方法
| 方法名 | 作用 |
|---|---|
| void put(Object key, Object value) | 插入 |
| Object get(Object key) | 获取 |
| boolean containsKey(Object key) | 判断是否包含某key |
| boolean containsValue(Object value) | 判断是否包含某value |
| Set KeySet() | 返回键的 Set 视图 |
| Collection<v> values()</v> | 返回值的 Collection 视图 |
| Set<Map, Entry<K, V>> entrySet() | 返回映射关系的 Set 视图 |
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class Test {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("1", "Jack");
map.put("2", "Rose");
map.put("3", "Lucy");
map.put("3", "Mary"); // 覆盖前一个
System.out.println(map);
Set keySet = map.keySet(); // 获取键的集合
Iterator it = keySet.iterator();
while(it.hasNext())
{
Object key = it.next();
Object value = map.get(key);
System.out.println(key + ":" + value);
}
}
}
// {1=Jack, 2=Rose, 3=Mary}
// 1: Jack
// 2: Rose
// 3: Mary 第二种遍历方式
import java.util.*;
public class TestIter {
public static void main(String[] args) {
Map map = new HashMap();
map.put("浪里白条", "张顺");
map.put("及时雨", "松江");
map.put("行者", "悟空");
Iterator it = map.entrySet().iterator(); // 拿到map内部的entry
while(it.hasNext()){
Map.Entry entry = (Map.Entry) it.next();
System.out.println(entry.getKey()+"=>"+entry.getValue());
}
}
} LinkedHashMap
import java.util.*;
public class Test {
public static void main(String[] args) {
LinkedHashMap map = new LinkedHashMap();
map.put("1", "Jack");
map.put("2", "Rose");
map.put("3", "Lucy");
map.put("3", "Mary"); // 覆盖前一个
System.out.println(map);
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext())
{
Object key = it.next();
Object value = map.get(key);
System.out.println(key + ":" + value);
}
}
}
// {1=Jack, 2=Rose, 3=Mary}
// 1: Jack
// 2: Rose
// 3: Mary TreeMap
import java.util.*;
public class Test {
public static void main(String[] args) {
TreeMap map = new TreeMap();
map.put("1", "Jack");
map.put("2", "Rose");
map.put("3", "Lucy");
map.put("3", "Mary"); // 覆盖前一个
System.out.println(map);
Set keySet = map.keySet();
Iterator it = keySet.iterator();
while(it.hasNext())
{
Object key = it.next();
Object value = map.get(key);
System.out.println(key + ":" + value);
}
}
}
// {1=Jack, 2=Rose, 3=Mary}
// 1: Jack
// 2: Rose
// 3: Mary 自定义比较器
import java.util.Comparator;
public class MyComparator implements Comparator {
public int compare(Object obj1, Object obj2)
{
String id1 = (String)obj1;
String id2 = (String)obj2;
return id2.compareTo(id1); // 降序排列
}
} import java.util.*;
public class Test {
public static void main(String[] args) {
TreeMap map = new TreeMap(new MyComparator());
map.put("1", "Jack");
map.put("2", "Rose");
map.put("3", "Lucy");
map.put("3", "Mary"); // 覆盖前一个
System.out.println(map);
Iterator it = map.keySet().iterator();
while(it.hasNext())
{
Object key = it.next();
Object value = map.get(key);
System.out.println(key + ":" + value);
}
}
}
// {3=Mary, 2=Rose, 1=Jack}
// 3:Mary
// 2:Rose
// 1:Jack 常用操作:
- 相同的key会把前面保存的数据顶掉.
- get(key) 使用key查询value
- isEmpty() 判断Map是否是空的
- size() 返回key, value键值对的个数
- containsKey(key) 判断是否存在key
- remove(key) 根据key删除信息
- keySet() 获取到map中key的集合set
import java.util.HashMap;
import java.util.Map;
public class TestMap {
public static void main(String[] args) {
Map map = new HashMap();
map.put("q", "冲啊");
map.put("w", "打不动我吧!!!");
map.put("e", "爱的魔力转转圈");
map.put("r", "德玛西亚!!!!");
System.out.println(map); // {q=冲啊, r=德玛西亚!!!!, e=爱的魔力转转圈, w=打不动我吧!!!}
map.put("w", "我挡!!"); // w被顶掉了
System.out.println(map); // {q=冲啊, r=德玛西亚!!!!, e=爱的魔力转转圈, w=我挡!!}
System.out.println(map.get("q")); //冲啊
System.out.println(map.isEmpty()); // 是不是空的 false
System.out.println(map.size()); // map里有多少key,value 4
System.out.println(map.containsKey("r")); // 是否包含了xxxkey true
map.remove("e"); // 删除key为e的键值对
System.out.println(map); // {q=冲啊, r=德玛西亚!!!!, w=我挡!!}
System.out.println(map.keySet()); // 获取到所有的key的set集合 [q, r, w]
}
} 容器的泛型
规范容器的类型
import java.util.ArrayList;
import java.util.List;
public class TestParadigm {
public static void main(String[] args) {
List<String> list = new ArrayList<String>(); // 强制规定这个列表只能装字符串
// list.add(1);// 报错. 只能装字符串
list.add("NB"); // OK
// 好处是, 从list中获取到的数据不需要强转了.
String s = list.get(0) ;// 这个列表只能装字符串, 拿出来也一定是字符串
System.out.println(s);
}
} 创建一个只能装歌手的列表
import java.util.ArrayList;
import java.util.List;
public class TestParadigm {
public static void main(String[] args) {
List<Singer> singerList = new ArrayList<Singer>(); // 只能装歌手
Singer singer = new Singer();
singerList.add(singer); // 添加歌手
Singer ss = singerList.get(0); // 查询歌手
System.out.println(ss);
}
} Set集合和List的泛型是一样的. 强制规定集合中元素的类型
Map集合的泛型比较特殊. 因为这个鬼东西里面有key和value.两项内容.
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class TestParadigm {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("萝莉", "小蔡");
map.put("御姐", "苏打强");
// map.put(1, 2) ; // 报错, 只能是字符串
String v = map.get("萝莉");
System.out.println(v);
}
}
OK. 泛型的语法咱们明白了. 那这玩意有什么用呢?
规范集合. 存储数据方便. 不再需要强转了. 在以后的代码中, 如果没有特殊要求. 还是给出泛型比较好.
自定义泛型
public class CachePool<T> {
T temp;
public void save(T temp)
{
this.temp = temp;
}
public T get()
{
return this.temp;
}
} import java.util.*;
public class Test {
public static void main(String[] args) {
CachePool<Integer> pool = new CachePool<Integer>();
pool.save(new Integer(1));
Integer temp = pool.get();
System.out.println(temp); // 1
}
} Collections 工具类
在java中提供了Collections工具类来帮助我们去操作 List 集合类.
| 方法名 | 作用 |
|---|---|
| static boolean addAll(Collection c, Object elements) | 添加多个元素 |
| static void reverse(List list) | 反转 |
| satic void shuffle(List list) | 洗牌 |
| static void sort(List list) | 排序 |
| static void swap(List list, int i,int j) | 交换 |
| static int binarySearch(List list, Object key) | 二分法查找 |
| static Object max(Collection col) | 返回最大值 |
| static Object min(Collection col) | 返回最小值 |
| static boolean replaceAll(List list, Object oldVal, Object newVal) | 一个新值替换所有旧值 |
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<Integer> lst = new ArrayList<Integer>();
lst.add(123);
lst.add(321);
lst.add(147);
Collections.sort(lst); // 排序
System.out.println(lst);
Collections.shuffle(lst); // 打乱顺序
System.out.println(lst);
Collections.sort(lst); // 重新排序
Collections.reverse(lst); // 翻转
System.out.println(lst);
int max = Collections.max(lst); // 最大值
int min = Collections.min(lst); // 最小值
System.out.println(max);
System.out.println(min);
Collections.addAll(lst,-3, 2, 8, 8, 8); // 添加
System.out.println(lst);
Collections.replaceAll(lst, 8, 0); // 替换
System.out.println(lst);
}
} Arrays工具类
void Arrays.sort(array); // 数组排序 int index Arrays.binarySearch(Object[] a, Object key); // 查找某元素的下标, 返回索引 Object[] Arrays.copyOfRange(int[] original, int from, int to); // 拷贝数组 void Arrays.fill(Object[] a, Object val); // 填充数组中全部元素 String Arrays.toString(int[] arr); // 将数组转化为字符串
import java.util.*;
public class Test {
public static void main(String[] args) {
int []arr = {9, 8, 3, 5, 2};
// 排序
Arrays.sort(arr);
// 查找
int index = Arrays.binarySearch(arr, 3);
// 拷贝, 多余的用0填充
int[] copy = Arrays.copyOfRange(arr, 1, 7);
// 填充
Arrays.fill(arr, -1);
// 转化为字符串
System.out.println(Arrays.toString(arr));
}
} IO文件
- 字节流
- java.io.InputStream
- java.io.OutputStream
- 字符流
- java.io.Reader
- java.io.Writer
InputStream常用方法
| 方法名 | 作用 |
|---|---|
| int read() | 读入一个字节, 将其转化为0-255之间的整数, 并返回 |
| int read(byte[] b) | 读入若干字节, 将它们保存到参数b指定的字节数组中, 返回读取的字节数 |
| int read(byte[] b, int off, int len) | 读取若干字节, 将他们保存到参数b指定的数组中, off起始下标, len表字节数 |
| void close() | 关闭此输入流并释放与该流关联的所有系统资源 |
OutputStream常用方法
| 方法名 | 作用 |
|---|---|
| void write(int b) | 写入一个字节 |
| void write(byte[] b) | 将b的所有字节写到输出流中 |
| void write(byte[] b,int off,int len) | 指定byte数组中从偏移量off开始的len个字节写入输出流 |
| void flush() | 刷新输出流并强制写出所有缓冲的输出字节 |
| void close() | 关闭此输入流并释放与该流关联的所有系统资源 |
FileInputStream 和 FileOutputStream
- 读入
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception{
FileInputStream in = new FileInputStream("C:\Users\Dylan\Desktop\test.txt");
int b = 0;
while(true)
{
b = in.read();
if(b == -1)
{
break;
}
System.out.println(b);
}
in.close();
}
}
// 105
// 116
// 99
// 97
// 115
// 116
- 输出
```java
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception{
// FileInputStream in = new FileInputStream("C:\\Users\\Dylan\\Desktop\\test.txt");
FileOutputStream out = new FileOutputStream("C:\\Users\\Dylan\\Desktop\\temp.txt");
String str1 = "中国";
byte[] b1 = str1.getBytes("utf-8"); // 转化为字节数组 gbk一个汉字2字节, utf-8一个汉字3字节
System.out.println(b1.length); // 6
String str2 = "China";
byte[] b2 = str2.getBytes("gbk"); // 转化为字节数组 gbk一个英文1字节, utf-8一个英文1字节
System.out.println(b2.length); // 5
for(int i=0;i<b2.length;i++)
{
out.write(b2[i]);
}
out.close();
}
}- 追加
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception {
FileOutputStream out = new FileOutputStream("example.txt", true); // 第二个参数表追加
String str = "欢迎您";
byte[] b = str.getBytes("gbk");
for(int i=0;i<b.length;i++)
{
out.write(b[i]);
}
out.close();
}
}
- 文件拷贝
```python
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception {
FileInputStream in = new FileInputStream("C:\\Users\\Dylan\\Desktop\\test.jpg");
FileOutputStream out = new FileOutputStream("C:\\Users\\Dylan\\Desktop\\test_new.jpg");
int b;
long begintime = System.currentTimeMillis();
while ((b = in.read()) != -1)
{
out.write(b);
}
long endtime = System.currentTimeMillis();
System.out.println("拷贝文件所需要的时间是: " + (endtime-begintime) / 1000.0 +"秒");
in.close();
out.close();
}
}
// 拷贝文件所需要的时间是: 0.387秒- 字节流的缓冲区
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception {
FileInputStream in = new FileInputStream("C:\\Users\\Dylan\\Desktop\\test.jpg");
FileOutputStream out = new FileOutputStream("C:\\Users\\Dylan\\Desktop\\test_new.jpg");
byte[] buff = new byte[1024];
int len; // 记录读入缓冲区的大小
long begintime = System.currentTimeMillis();
while((len=in.read(buff)) != -1)
{
out.write(buff,0,len); // 从第一个字节开始, 写入len个字节
}
long endtime = System.currentTimeMillis();
System.out.println("拷贝文件所需要的时间是: " + (endtime-begintime) / 1000.0 +"秒");
in.close();
out.close();
}
}
// 拷贝文件所需要的时间是: 0.001秒 - 装饰设计模式
public class Car {
private String carName;
public Car(String carName)
{
this.carName = carName;
}
public void show()
{
System.out.println("我是" + carName + ", 具有基本功能");
}
} public class RadarCar {
public Car myCar;
public RadarCar (Car myCar)
{
this.myCar = myCar;
}
public void show()
{
myCar.show();
System.out.println("具有雷达功能");
}
} public class Test {
public static void main(String[] args) {
Car benz = new Car("Benz");
System.out.println("--------------包装前--------------");
benz.show();
RadarCar decoratedCar_benz = new RadarCar(benz);
System.out.println("--------------包装后--------------");
decoratedCar_benz.show();
}
}
// --------------包装前--------------
// 我是Benz, 具有基本功能
// --------------包装后--------------
// 我是Benz, 具有基本功能
// 具有雷达功能 - 字符缓冲流
- BufferedInputStream
- BufferedOutputStream
- 两者都使用装饰设计模式, 构造方法接收InputStream和OutputStream对象
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception{
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("src.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("dsc.txt"));
int len;
while((len=bis.read()) != -1)
{
bos.write(len);
}
bis.close();
bos.close();
}
} FileReader 和 FileWriter
- 读
import java.io.*;
public class Test {
public static void main(String[] args) throws Exception{
FileReader reader = new FileReader("C:\\Users\\Dylan\\Desktop\\test.txt");
int ch;
while ((ch=reader.read()) != -1)
{
System.out.println(ch); // 输出字符的十进制数字
System.out.println((char)ch); // 输出字符
}
reader.close();
}
} - 写
京公网安备 11010502036488号