java常见类——工具类

最新推荐文章于 2024-04-04 22:52:40 发布

Rro_aa

最新推荐文章于 2024-04-04 22:52:40 发布

阅读量4.7k

点赞数 4

文章标签： java 开发语言

本文链接：https://blog.csdn.net/rrros/article/details/124825123

版权

工具类

Java开发者写好的类—官方文档 API

包装类(封装类)

1.5版本之后自动拆装包

[基本类型]: byte—Byte short—Short int—Integer long—Long

float—Float double—Double boolean—Boolean char—Character

1.八个包装类都在Java.lang包下，不需要导包
2.八个包装类中六个数字相关都默认继承父类Number
3.八个包装类都实现了Serializable，Comparable
4.均有带有自己对应类型参数构造方法，除了Character都有String构造方法重载
5.创建对象对象调用属性/方法
六个数字相关类继承Number

        xxxValue();//将一个包装类类型转化为对应的基本类型（拆包)
        
        Integer i1 = new Integer(10);//引用数据类型 包装类
		int value = i1.intValue();

		Integer i2 = 10;
		int value = new Integer(10);

		int value = Integer.parseInt("123");	Float.parseFloat("123.45")
		int value = new Integer("123");

6.经常在笔试中出现的问题

		Integer i1 = 10;
		Integer i2 = 10;
		Integer i3 = new Integer(10);
		Integer i4 = new Integer(10);
		System.out.println(i1==i2);//  true--->如果数字范围超过127false
		System.out.println(i1==i3);//  false
		System.out.println(i3==i4);//  false
		System.out.println(i1.equals(i2));//true
		System.out.println(i1.equals(i3));//true
		System.out.println(i3.equals(i4));//true

1.==与equals()区别

= =可以比较基本数据类型也可以比较引用数据类型 (变量中存储的内容)
如果比较基本类型比较是变量中存储的值
如果比较引用类型比较是变量中存储的地址引用
equals()是Object类中继承过来的方法每一个引用类型都可以调用
默认继承的equals()方法比较与==一致如果想要改变比较规则可以重写equals方法
由于Integer类就重写了equals() 所以Integer比较的是数值

2.考察Integer类加载的时候自己有一个静态的空间

空间内立即加载 Integer类型的数组内存储256个Integer对象 -128 ~ 127
如果我们用的对象范围在这之内Integer i1 = 10; 直接取静态区中找对应的对象
如果我们用的对象范围超出了这个Integer i1 = 1000;
会帮我们创建一个新的Integer对象

数学相关

Math类

1.所属的包Java.lang
2.Math的构造方法是私有的，外部不能直接调用创建对象
3.Math中的属性和方法都是静态static，不需要创建对象，类.属性/方法调用
4.常用方法：
abs()返回给定数字的绝对值
double=ceil()向上取整
double=floor()向下取整
double=rint()临近的整数如果两边距一样，返回偶数
int = round() 四舍五入的整数
max(a,b) min(a,b) (参数int long float double)
pow(a,b) a的b次方 (参数double 返回值double)
sqrt(double a) 获取给定参数的平方根
double = random(); 随机产生一个 [0.0–1.0)
5.Math.random()计算小数的时候精确程度可能有些损失
0-9之间的随机整数
int value = (int)(Math.random()*10);
5.0—10.9之间的小数
(Math.random()*6)+5
0.0—0.99999 * 6
(0.0—5.49999)+5

Random类

1.在java.util包中的类需要import导入
2.没有任何继承关系默认继承Object类
3.查找构造方法—>如何创建对象
Random r = new Random();
4.类中提供的常用方法
r.nextInt(); 随机产生 int取值范围的整数有正有负
r.nextInt(int bound); 随机产生一个 [0–bound) 整数
注意bound必须为正数否则会出现如下的运行时异常
IllegalArgumentException
r.nextFloat() 随机产生一个 [0.0—1.0)
r.nextBoolean() 随机产生一个boolean值 true false

UUID类

1.所属的包 java.util 需要import导入
2.没有任何继承关系默认继承Object类
3.构造方法有没有无参数的我们通常不会创建对象
UUID uuid = UUID.randomUUID();
System.out.println(uuid.toString());//数据库表格主键 primary key
产生一个32位的随机元素每一个位置是一个16进制的数字

BigInteger类

大整数 long -2的63次方 ~ 2的63次方-1

1.所属的包java.math 需要import导入
2.继承自Number
3.如何创建对象提供的构造方法全部都是带参数的
通常利用带String参数的构造方法创建这个类的对象
BigInteger bi = new BigInteger(“123”);
4.类中的常用方法
做四则运算
add() subtract() multiply() divide()
5.小例子
设计一个方法用来计算给定数字的阶乘 5 1 * 2 * 3 * 4 * 5==120

		//设计一个方法  用来计算给定数字的阶乘  
		//参数   返回值  
		public BigInteger factorial(int num){  
			BigInteger result = new BigInteger("1");  
			for(int i=1;i<=num;i++){  
				result = result.multiply(new BigInteger(i+""));  
			}  
			return result;  
		}

BigDecima类超过了double取值范围

1.所属的包 java.math包
2.继承Number类
3.通常也是可以通过带String参数构建对象
4.类中的常用方法
做四则运算
add() subtract() multiply() divide()
两个参数前面是保留小数点之后的位数后面参数是设置的模式
对象.setScale(2,BigDecimal.ROUND_DOWN);

DecimalFormat

将小数点之前和之后的位数都能处理的类---->格式化

1.所属的包 java.text
2.import导入才能使用
3.通过带String参数的构造方法创建一个格式化对象 0 #
4.调用format方法将一个小数格式化成一个字符串

		DecimalFormat df = new DecimalFormat("000.###");// 0必须存在 #可有可无  
        		String value = df.format(12.45);  
        		System.out.println(value);

Scanner类

1.所属的包java.util包需要import导包
2.通过一个带输入流的构造方法创建对象
3.常用方法

类型相关nextInt() nextFloat() [以回车符作为截尾，不读取]
字符串形式next()[以空格作为截尾，不读取空格] nextLine()//读取到回车符，并丢弃

System类

1.所属的包java.lang包不需要导入
2.不需要创建对象通过类名就可以访问
3.有三个属性及若干的方法
三个属性:out输出流 in输入流 err处理错误信息
方法gc()提示GC回收垃圾 exit(0);退出
currentTimeMillis();返回当前毫秒时间距离1970-1-1 00:08:00

日期相关

Date类

1.通常使用的是java.util包
2.导包拿来使用构建对象
3.通常使用无参数的构造方法或者带long构造方法
4.Date类中常用的方法
before(); after();
setTime() getTime();----->long
compareTo(); -1 1 0
5.可以处理一个Date日期的格式

DateFormat类

1.包java.text 需要导包使用
2.此类是一个抽象类不能创建对象子类来使用
3.SimpleDateFormat类是DateFormat的子类
4.调用带String参数的构造方法创建format对象

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        		String v =  sdf.format(date1);//通过sdf对象将date1格式化成你描述的样子

Calendar类 1.1版本

1.所属的包java.util 需要导包
2.有构造方法用protected修饰的通常访问不到通常会调用默认的getInstance();
3.常用方法
after() before()
setTime() getTime()---->Date
getTimeInMillis()----time
getTimeZone()—TimeZone
Calendar里面包含一个date属性可以操作date的某一个局部信息
set get
calendar.set(Calendar.YEAR,2015);
int year = calendar.get(Calendar.YEAR);
MONTH差一个月，西方从0开始数

TimeZone

1.java.util包
2.可以通过calendar对象.getTimeZone()获取或 TimeZone.getDefault();
3.常用方法
tz.getID() ----> Asia/Shanghai
tz.getDisplayName() 中国标准时间

字符串

String类---->引用类型 java.lang包

0.常见的String笔试题
== equals方法的区别
== 可以比较基本类型可以比较引用类型
比较基本类型比较值比较引用类型比较地址
equals只能比较引用类型(方法)
默认比较地址this==obj
如果想要修改其比较规则可以重写equals方法
通常重写equals方法时会伴随着重写hashCode方法
比如String类比如Integer
*String的不可变特性
长度及内容
String与StringBuffer区别
StringBuffer与StringBuilder区别
String对象的存储
“abc”---->字符串常量池
new String(“abc”)—>堆内存
“a”+“b”+“c”+“d”
*String中常用的方法
1.存在哪儿 java.lang包
没有任何继承关系实现三个接口Serializable, CharSequence, Comparable
2.如何构建对象

			String str = "abc"; //直接将字符串常量赋值给str   (字符串常量池)  
			String str = new String();//无参数构造方法创建空的对象  
			String str = new String("abc");//带string参数的构造方法创建对象  
			String str = new String(byte[] )//将数组中的每一个元素转化成对应的char 组合成String  
			String str = new String(char[]   )//将数组中的每一个char元素拼接成最终的String

3.String的不可变特性

String类中包含一个private final char[] value;
体现在两个地方长度及内容
长度—>final修饰的数组数组长度本身不变 final修饰数组的地址也不变
内容—>private修饰的属性不能在类的外部访问

*4.常用的方法

			boolean = equals(Object obj);
				//继承自Object 重写啦  比较两个字串中的字面值是否相等
				equalsIgnoreCase()//忽视大小写比较
			int = hashCode();
				//继承自Object 重写啦  将当前字符串的每一个char元素拆开 乘以31求和
			int = compareTo(String str);
				//实现自Comparable接口  实现啦  按照字典(Unicode编码)索引的顺序比较
				//按照两个字符串的长度较小的那个(次数)来进行循环
		        //若每次的字符不一致 则直接返回code之差 
		        //若比较之后都一致  则直接返回长度之差
		        compareToIgnoreCase()//忽视大小写比较
			String = toString();
				//继承自Object 重写啦 不再输出 类名@hashCode  字符串中的字面值
			--------------------------------------------------------------------
			char = charAt(int index);//"abc"   0-->a
				//返回给定index对应位置的那个char值
			int = codePointAt(int index);//"abc"   0-->97
				//返回给定index对应位置的那个char所对应的code码
			int = length();
				// 返回字符串的长度   (其实就是底层char[] value属性的长度)
		        //注意:  区别数组length是属性  String的length()方法    集合size()方法
			String = concat(String);
				//将给定的字符串拼接在当前字符串之后
				//注意:  方法执行完毕需要接受返回值   String的不可变特性
		        //  concat方法与   +拼接的性能问题
		        //  开发中若遇到频繁的拼接字符串--->通常使用StringBuilder/StringBuffer
			//自己回去查看API文档

    8.boolean = contains(CharSequence s);  
	   判断给定的s是否在字符串中存在
	9. startsWith(String prefix);  
	    endsWith(String suffix);
	   判断此字符串是否已xx开头/结尾
	10.byte[] = getBytes();   --->    getBytes(String charsetName);
	     char[] = toCharArray();
	   将当前的字符串转化成数组   "我爱你中国"   char[]  '我' '爱' '你' '中' '国'
	11. int index = indexOf(int/String str [,int fromIndex] );   四个方法重载
	   找寻给定的元素在字符串中第一次出现的索引位置   若字符串不存在则返回-1
	      lastIndexOf(int/String str , [int fromIndex]);
	   找寻给定的元素在字符串中最后一次出现的索引位置  若不存在则返回-1
	12.boolean = isEmpty();
	   判断当前字符串是否为空字符串  (length是否为0)
	   注意： 与null之间的区别
	13.replace();
	     replaceAll();
	     replaceFirst(); 换第一次出现的那个字串
	   将给定的字符串替换成另外的字符串
	14.String[] = split(String regex [,int limit限度界限]);
	   按照给定的表达式将原来的字符串拆分开的
	15.String = substring(int beginIndex [,int endIndex]);
	   将当前的字符串截取一部分   
	   从beginIndex开始至endIndex结束  [beginIndex,endIndex)
	   若endIndex不写 则默认到字符串最后
	16.String = toUpperCase();
	     String = toLowerCase();
	  将全部字符串转换成大写/小写
	17.String = trim();
	  去掉字符串前后多余的空格
	18.boolean = matches(String regex)
	  regular有规律的 expression表达式

常用的方法
代码学习44

    第一梯队(重写)
	equals  hashCode  compareTo  toString
    第二梯队(常用)
	    charAt()  codePointAt()
	    indexOf()  lastIndexOf()
	    substring()  split()  replace()
	    length()  concat()  contains();  trim();
	    getBytes()   toCharArray()  matches()
	第三梯队(一般)
	    toUpperCase()  toLowerCase()
	    startsWith()  endsWith();
	    isEmpty();

StringBuffer和StringBuilder

1.所属的包 java.lang包
2.继承AbstractStringBuilder 间接继承 Object
实现接口Serializable,CharSequence,Appendable
StringBuffer/StringBuilder没有compareTo方法
StringBuffer/StringBuilder含有一个String没有的方法 append();拼接
3.特性
可变字符串 char[] value; 动态扩容
4.对象的构建

		//无参数构造方法  构建一个默认长度16个空间的对象  char[]
		StringBuilder builder = new StringBuilder();
		//利用给定的参数 构建一个自定义长度空间的对象 char[]
		StringBuilder builder = new StringBuilder(20);
		//利用带String参数的构造方法  默认数组长度字符串长度+16个
		StringBuilder builder = new StringBuilder("abc");

5.StringBuilder中常用的方法

  最主要的方法 append()  频繁的拼接字符串的时候使用此方法 提高性能  
  ensureCapacity(int minimumCapacity)  确保底层数组容量够用  
  capacity();//字符串底层char[]的容量  
  length();//字符串有效元素个数(长度)  
  setLength();//设置字符串的有效元素个数  
  char = charAt(int index);  
  int = codePointAt(int index);  
  String = substring(int start [,int end]);  
  	注意需要接受返回值 看见截取出来的新字符串效果    
  StringBuilder = delete(int start [,int end]);    
  	StringBuilder类中独有的方法String类没有  
  	将start到end之间的字符串删掉  不用接受返回值就看到效果啦  
  StringBuilder = deleteCharAt(int index);  
  	String类中没有的方法  
  	将给定index位置的某一个字符删除掉啦
  int = indexOf(String str [,int fromIndex]);
  int = lastIndexOf(String str [,int fromIndex])
  	找寻给定的str在字符串中第一次出现的索引位置  带重载 则从某一个位置开始找
  insert(int index,value);
  	将给定的value插入在index位置之上
  replace(int start,int end,String str);
  	将start和end之间的部分替换成str
  	builder.replace(2,5,"zzt");
  setCharAt(int index,char value);
  	将index位置的字符改成给定的value
  toString()
  	将StringBuilder对象 构建成一个string对象 返回
  trimToSize()
  	将数组中无用的容量去掉  变成length长度的数组

知识总结

1.StringBuilder类不一定需要是为了避免String频繁拼接修改字符串信息的时候才用的
底层数组是可变的提高了性能

2.常用方法

  与String类不同的独有方法
  append()  insert()  delete()  deleteCharAt()  reverse()
  与String类相同的方法
  length() charAt() codePointAt() indexOf() lastIndexOf() 
  substring() replace()名字相同 用法不一致
  不是很常用的方法
  ensureCapacity() capacity() setLength() trimToSize(); setCharAt();

3.String家族笔试中经常容易考察的知识点

  1.String所属的包 继承关系 实现接口
  	java.lang 继承Object 接口Serializable,CharSequence,Comparable
  2.String构建方式
  	常量  构造方法  
  3.String对象内存结构
  	字符串常量区  new堆内存对象
  	==  equals()区别
  	"a"+"b"+"c"
  4.String不可变特性
  	长度及内容
  5.String中的常用方法---与StringBuilder的区别
  	concat();  toUpperCase();
  6.String和StringBuilder区别   |   String和StringBuffer区别
  	String不可变字符串
  		JDK1.0
  		有一个接口Comparable
  		不可变体现在长度及内容
  		有一些方法StringBuilder没有 concat  compareTo  toUpperCase
  	StringBuilder可变字符串
  		JDK1.5
  		有一个接口Appendable
  		可变字符串  没有final修饰  底层可以进行数组扩容
  		有一些方法String没有  append() insert() delete() reverse()
  7.StringBuffer和StringBuilder的不同
  	StringBuffer早期版本1.0
  	StringBuilder后来的版本1.5
  	早期版本  线程同步   	   安全性比较高  执行效率相对较低
  	后期版本  线程非同步    安全性比较低  执行效率相对较高

regex正则表达式

Regular有规律的 Expression表达式
一个带有一定规律的表达式
匹配字符串格式的

正则表达式通常的作用如下:
1.字符串的格式校验		String类中提供的一个方法 boolean = str.matches("regex");
2.字符串的拆分及替换		String类中提供的方法replace  split
3.字符串的查找		Pattern模式  Matcher匹配器

	如下的所有都用来描述字符的信息
	[abc]	abc其中的一个
	[^abc]	不能是abc其中的一个 其他都可以
	[a-zA-Z]	表示必须是这两个范围内的
	[a-z&&[^bc]]  表示a-z其中的一个但不能是b和c
	|	或者
	. 代表任意一个字符
	\d  digit数字   [0-9]
	\D  非数字       [^0-9]
	\s  space留白  一个空格 一个回车 一个换行。。。
	\S  非留白
	\w  word单词  [0-9A-Za-z]  数字或字母都可以
	\W 非单词        [^0-9A-Za-z]

	如下的所有都用来描述字符出现的次数
	?   0-1次    [0-9]?
	*   0-n次
	+  1-n次
	{n} 固定n次
	{n,} 至少出现n次
	{m,n}  m-n次

集合相关（ArrayBox LinkedBox）

集合java.util
Collection Map
存储的都是value 存储的是以key-value形式存在
List Set
有序可重复无序无重复 key无需无重复 value无需可重复

序 : 顺序	添加进去的元素  取得元素的顺序一致   注意指的不是集合自己的顺序
重复：两个对象元素一致

ArrayList  Vector区别--->StringBuilder  StringBuffer


List集合
1.ArrayList   3.Vector   2.LinkedList

ArrayList----->底层就是一个数组

	所属的包 java.util
	如何创建对象
	无参数构造方法    带默认空间的构造方法    带collection参数的构造方法
	常用的方法---小容器
		存 add
		取 get
		删 remove
		改 set
		个数  size

		add(E e)   add(int index,E e)
		addAll(Collection c);   add(int index,Collection c)
		clear();将集合内的全部元素清除
		boolean = contains(Object);找寻某一个给定的元素是否在集合中拥有
		ensureCapacity(int minCapacity);
		E = get(int index);
		int = indexOf(Object obj);  lastIndexOf();
		boolean = isEmpty();
		Iterator = list.iterator();//迭代器
		remove(int index)  remove(Object obj)
		removeAll()差集
		retainAll();交集
		E = set(int index,E value)
		int size();
		List = subList(int begin,int end);
		toArray();	集合变成数组
		toArray(T[] );
		trimToSize();// 变成有效元素个数那么长

LinkedList类

1.java.util包自己封装过LinkedBox 内部类Node对象(节点 prev item next)
2.底层使用双向链表的数据结构形式来存储
适合于插入或删除不适合遍历轮询
3.构建对象
无参数构造方法带参数的构造方法(collection)
4.常用的方法

  增删改查   add()  remove()  set()  get()  size()	offer  poll   peek
  手册中提供的其他常用方法
  addAll   addFist   addLast()  clear()  contains()
  element()  getFirst()  getLast()  indexOf()  lastIndex()
  .....

5.插入删除的特性是否像想的那样
对比ArrayList Linked

关于泛型的问题：

  由于arrayList底层是一个Object[]  什么类型都可以存进去
  取出来的时候多态的效果 需要自己造型 显得用起来非常的麻烦
  JDK1.5之后--->泛型
  用来规定数据类型的，定义的时候用一个符号代替某种类型
  在使用的时候用具体的数据类型 将定义的那个符号替换掉
  泛型可以用在哪里?
  1.泛型类
  	类定义的时候描述某种数据类型  集合的使用就是这样
  2.泛型接口
  	与泛型类的使用基本一致   子类实现接口时必须添加泛型
  3.泛型方法
  	方法调用时传参数   方法的泛型与类无关   带有泛型的方法可以不放在带有泛型的类中
  4.高级泛型  规范边界  extends  super

Vector类

1.java.util包
2.是ArrayList集合的早期版本 (StringBuffer早期 StringBuilder后来)
Vector底层也是利用(动态)数组的形式存储
Vector是线程同步的(synchronized) 安全性高效率低
3.扩容方式与ArrayList不同
默认是扩容2倍可以通过构造方法创建对象时修改这一机制
4.构造方法
5.常用方法

Stack类栈

1.java.util包
2.构造方法只有一个无参数
3.除了继承自Vacton类的方法外还有特殊的方法
push(E e)将某一个元素压入栈顶(add())
E = pop()将某一个元素从栈顶取出并删掉(E = remove())
E = peek()查看栈顶的一个元素不删除(get())
boolean = empty()判断栈内元素是否为空(isEmpty())
int = search()查找给定的元素在占中的位置(indexOf())
4.中国象棋悔棋
栈中存储每一次操作的步骤
撤销功能

Queue接口

1.java.util 通常子类LinkedList ArrayDeque
2.通常无参数构造方法创建
3.一般方法

  add()
  element()---->get()
  remove()
  boolean = offer(E e);//相当于add	不会抛出异常
  E = peek();//相当于 element方法
  E = poll();剪短//  相当于remove()

4.双十一零点秒杀
所有进入秒杀系统的人存入队列
Collection 以value形式存在

Set 无序无重复

1.具体的实现类
HashSet
TreeSet
2.基本的使用
3.无序无重复
无序：我们使用集合存放元素的顺序集合内取出来的顺序不一致
集合本身是有自己的算法排布顺序 hash算法

HashSet---->(HashMap (数组+链表) 散列表临接连表)

1.java.util
2.如何创建对象无参数有参数

3.集合容器的基本使用

    增删改查
	boolean = add(value)   addAll(collection c)   retainAll   removeAll
	boolean = remove(Object)
	没有修改方法
	iterator()  获取一个迭代器对象
	size()

4.无重复的原则

  	首先通过String类型和Person类型存储
  	大概猜测  无重复的原则  利用equals方法进行比较
  	如果我们想要让Person对象的name一致 认为是同一个对象
  	我们可以重写equals方法
  	重写了equals方法  发现还没有产生无重复的效果
  	证明可能原则不止equals一个方法这么简单
  	还有另一个规则同时起着作用 hashCode方法  int
  	五个Person对象只剩一个   第一次存储的   还是最后一次存储
  	set集合是发现重复的元素 拒绝存入  存储的是第一个

TreeSet-----(TreeMap 二叉树利用Node(left item right))

无序无重复 java.util
无参数构造方法带Collection构造方法
基本常用方法

  	add(E e)  iterator()  remove(E e)  没有修改  size()

无重复的规则是如何实现的

  	treeSet集合本身有顺序   我们指的无序存入的和取出来的不一致
  	compareTo---->String类  按照字母的自然顺序排布(Unicode)
  	如果想要把自己写的类型 比如Person对象存入TreeSet集合里
  	不能随意的存储	需要让自己写的类先实现Comparable接口

Map

映射   通过某一个key可以直接定位到一个value值
存储的方式以  键值对  存储   key-value
key无序无重复   value无序可重复
key无序还是一样，指的是存入顺序与取得顺序不一致
key无重复当然指的是 元素不能一致

1.map基本使用
```
  HashMap
  TreeMap
  Properties
```

HashMap

1.包 java.util
2.如何创建对象
3.基本方法

  增删改查
  增put(key,value)	存放一组映射关系   key-value
  	1.key存储的顺序与取得顺序不同
  	2.不同的key可以存储相同的value
  	3.key若有相同的 则将 原有的value覆盖而不是拒绝存入(跟set刚好相反)
  删E = remove(key);
  改put(key,value1)    put(key,value2)
     replace(key,newValue)
  查E = get(key)
  遍历map集合?	key不一定什么样
  	获取到所有的key	遍历key	通过key获取value
  	Set<Key> = keySet()获取全部的key
  	Set<Entry> = entrySet();
  size();

4.除了上述几个常用的方法外其他API中提供的方法

  clear   containsKey(key)   containsValue(value)
  getOrDefault(key,defaultValue);如果key存在就返回对应的value 若没有找到则返回默认值
  isEmpty()
  putAll(map)
  putIfAbsent(key,value);//如果key不存在才向集合内添加  如果key存在就不添加啦

5.map集合在什么情形下用?

1.想要存储一组元素
数组 or 集合如果存储的元素以后长度不变用数组如果长度以后不确定用集合
2.如果发现长度以后不确定—>集合
List Set Map
List家族有序的存储有顺序用这个
ArrayList 更适合遍历轮询
LinkedList 更适合插入和删除
Stack LIFO
Set家族无重复存储元素希望自动去掉重复元素用这个
Hash 性能更高
Tree 希望存进去的元素自动去重复同时还能自动排序
Map家族k-v 通过唯一的k快速找寻v用这个
Hash 性能更高
Tree 希望存进去的元素key自动排序
6.登录小流程
能体会每一个不同集合的特点

7.HashMap底层的数据结构存储

散列表的形式	数组+链表
Person对象存入HashMap中?  可以
hashCode方法---->不同的对象 可以产生相同的hashCode码的
不同的hashCode码-->不同的对象

TreeMap

自然有序按照Unicode编码自然有序
map集合中的key需要可比较的 key的对象需要实现Comparable接口

1.java.util包
2.构造方法
无参数带map参数
3.常用方法
put get remove replace size
4.底层数据结构的存储
红黑二叉树

异常相关

程序运行过程中，可能会发生一些不被期望的效果，肯定会阻止我们的程序按照指令去执行
这种不被预期出现的效果，肯定需要抛出来告诉我们

在Java中有一个定义好的规则Throwable（可以抛出的）

Error错误
通常是一些物理性的，JVM虚拟机本身出现的问题，程序指令是处理不了的
Exception异常
通常是一种人为规定的不正常的现象，通常是给定的程序指令产生了一些不符合规范的事情
```
Throwable类实现了一个序列化接口
```
Error(错误) Exception(异常)
StackOverflowError RuntimeException(运行时) IOException。。。。。
OutOfMemoryError

异常的分支体系

运行时异常(非检查异常)

	Error和RuntimeException都算作运行时异常
	javac编译的时候，不会提示和发现的，
	在程序编写时不要求必须做处理，如果我们愿意可以添加处理手段(try throws)
	要求大家出现这样异常的时候 知道怎么产生及如何修改

1.InputMisMatchException 输入不匹配
int value = input.nextInt();// abc
*2.NumberFormatException 数字格式化
int value = Integer.parseInt(“123.45”);
3.NegativeArraySizeException 数组长度负数
int[] array = new int[-2];
*4.ArrayIndexOutOfBoundsException 数组索引越界
int[] array = {1,2,3};
array[5];
*5.NullPointerException 空指针异常

			int[][] array = new int[3][];
			array[0][0] =10;
			Person p = null;
			p.getName();

6.ArithmeticException 数字异常
10/0 整数不允许除以0 Infinity小数除以0会产生无穷
*7.ClassCastException 造型异常
Person p = new Teacher();
Student s = (Student)p;
*8.StringIndexOutOfBoundsException 字符串越界
String str = “abc”;
str.charAt(5);

*9.IndexOutOfBoundsException 集合越界

  	List家族
  	ArrayList  list = new ArrayList();
  	list.add(); list.add(); list.add();
  	list.get(5);

10.IllegalArgumentException 非法参数异常
```
  	ArrayList  list = new ArrayList(-1);
```

编译时异常(检查异常)

	除了Error和RuntimeException以外其他的异常
	javac编译的时候  强制要求我们必须为这样的异常做处理(try或throws)
	因为这样的异常在程序运行过程中极有可能产生问题的
	异常产生后后续的所有执行就停止啦

            InterruptException
			try{
				Thread.sleep(5000);
			}catch(Exception e){
	
			}

后续还会有很多的编译时异常

添加处理异常的两种手段

处理异常不是   异常消失了
处理异常指的是   处理掉异常之后   后续的代码不会因为此异常而终止执行

try{}catch(){}[ finally{} ]

1.try不能单独的出现
2.后面必须添加catch或finally
3.catch有一组括号 (NullPointerException) 目的是为了捕获某一种异常

4.catch可以有很多个存在

捕获的异常之间没有任何的继承关系
捕获的异常需要从小到大进行捕获

5.finally不是必须存在的

若存在finally结构  则必须执行
引申一个小问题:   final   finally  finalize区别
	final  特征修饰符  修饰变量 属性 方法 类
		修饰变量 基本类型 值不能改变 引用类型 地址不能改变(如果变量没有初值 给一次机会赋值)
		修饰属性 特点与修饰变量类似 (要求必须给属性赋初始值 否则编译报错)
		修饰方法 不能被子类重写
		修饰类    不能被其他的子类继承
	finally 处理异常手段的一部分
		try{}catch(){}后面的一个部分
		这个部分可有可无  如果有只能含有一份 且必须执行
	finalize 是Object类中的一个protected方法
		对象没有任何引用指向的时候 -- 会被GC回收
		当对象回收的时候 默认调用finalize方法
		若想要看到对象回收的效果  可以重写 public void finalize(){}

6.处理异常放在方法内部可能还会有小问题

如果在方法内部含有返回值
不管返回值return关键字在哪里   finally一定会执行完毕
返回值的具体结果   看情况

throws抛出

1.异常只能在方法上抛出属性是不能处理异常的
2.方法构造
3.方法可以抛出不止一个异常通过，隔开
4.抛出的异常与多个catch类似要么没关系要么先抛出小异常

Throwable的分支

Exception   Error
运行时
编译时
两种处理异常的手段 try  throws
常用的运行时异常  后续见到的编译时异常

我们也可以自己创建异常----自定义异常

1.自己描述一个异常的类
2.让我们自己的类继承
如果继承是RuntimeException---->运行时异常(不需要必须添加处理手段)
如果继承是Exception-------------->编译时异常(必须添加处理手段)
3.创建一个当前自定义异常类的对象
通过throw关键字主动产生异常
4.当我们设计描述的方法(事情) 之前没有相关的异常能描述我的问题Box
这个时候才会利用自定义异常来描述

输入输出相关I/O

I/O相关	输入/输出	   流(数据流动)
数据流动的方向   读数据(输入Input)   写数据(输出output)
文件流  字符流  对象流  网络流....
*文件流
	低级
		字节型	FileInputStream  FileOutputStream
		字符型	FileReader  FileWriter	字符集65279
	*缓冲
		字节型	BufferedInputStream  BufferedOutputStream
		字符型	BufferedReader	BufferedWriter
数组流
	byte数组		ByteArrayInputStream	ByteArrayOutputStream
	char数组		CharArrayReader		CharArrayWriter
数据流			DataInputStream		DataOutputStream
字符串流			StringReader		StringWriter
*对象流			ObjectInputStream		ObjectOutputStream

    1.什么叫文件
    一种电脑的存储形式
    文件有不同的格式   .txt   .doc   .ppt   .mp4   .jpg   .rar   ...
	文件夹?----目录路径
	
	2. 什么叫文件流   做什么
	读取文件中的内容		向文件中写内容
	文件输入流		文件输出流
	字节型文件输入流		字节型文件输出流
	字符型文件输入流		字符型文件输出流

容器
1.变量	只能存一份
2.数组	存储好多个    数据类型统一
3.集合	存储好多个    存储后个数还能改变    泛型---数据类型统一
如上三个都是Java中的类型(对象-->内存)
都存储在内存中  程序执行完毕  虚拟机停止的时候  内存空间就回收啦
数据都是临时性存储的
----------------------------
4.文件	存储好多信息
文件是存储在硬盘上的--->永久性保存
数据虽然是安全了
文件毕竟不在内存中  需要通过IO操作文件		JDBC
字符集
字符   文字和符号总称(Character)
不同国家的数字和符号是一样的   字母
不同国家的文字   中文   日文   韩文
计算机最早产生是按照英语单词  单个字符设计的
字母  数字  符号-----1字节   8bit   256
如果计算机想要处理除了上述字母符号以外的其他字符---比如中文2字节
需要将中文进行字符编码----->拆分 和 组合
拆分合组合的规则---所谓的字符编码

常见的字符编码

	ASCII	American Standard Code for Information Interchange
	ISO-8859-1
	GB2312   GB18030   GBK	BIG5
	Unicode
	UTF-8   UTF-16
	平台(操作系统)默认字符集GBK	Linux(MacOS)默认字符集UTF-8
	编程序使用的开发环境(IDE)   Idea-->UTF-8   Eclipse-->GBK
	注意在用记事本存储文字    流操作纯文本形式的时候
	字符的形式采用UTF-8
	String s = "你我他";
	byte[] = s.getBytes("UTF-8");
	new String(byte[],"UTF-8");

File----->与电脑上的文件或文件夹产生一一对应的映射关系

File是一个类

1.java.io包中
2.文件或目录路径名的抽象表示形式
3.File与真实硬盘中的文件或文件夹不是一个东西
File是在内存中的一个对象<—映射—>硬盘上的文件或文件夹

4.File类中的常用的方法

canRead()   canWrite()   isHidden()   isFile()   isDirectory()
length()获取文件中字节的个数
lastModified()获取文件最后的修改时间--->毫秒值
*String path = getAbsolutePath()  获取文件的绝对路径   D://test//Test.txt
绝对路径<---->相对路径
绝对路径可以通过完整的字符串  定位盘符 文件夹 文件
相对路径没有盘符的写法           当前工程(项目)所在的位置找寻
		C:\Users\Administrator\IdeaProjects\TestFile
String name = getName() 获取文件的名字    Test.txt
*boolean = createNewFile()  创建新的文件
*boolean = mkdir	              创建新的文件夹  外层没有 不能创建
*boolean = mkdirs             创建新的文件夹  外层没有 可以自动创建
String pname = getParent()  获取当前file的父亲file名字
*File file = getParentFile()      获取当前file的父亲file对象
String[] names = list()            获取当前file的所有儿子名字
*File[] files = listFiles()             获取当前file的所有儿子对象
*boolean = delete()	删除文件或空的文件夹  不能删除带元素的文件夹

学习文件流—>

	顾名思义  读取文件中的信息in   将信息写入文件中out
	文件流按照读取或写入的单位(字节数)大小来区分

	字节型文件流(1字节)
		FileInputStream/FileOutputStream
	字符型文件流(2字节--1字符)
		        FileReader/FileWriter

字节型文件输入流 FileInputStream

1.包 java.io
2.了解一下继承关系 InputStream类字节型输入流的父类
3.创建对象
调用一个带File类型的构造方法
调用一个带String类型的构造方法
4.常用方法
```
int code = read();	每次从流管道中读取一个字节   返回字节的code码
```
*int count = read(byte[] ) 每次从流管道中读取若干个字节存入数组内返回有效元素个数
int count = available(); 返回流管道中还有多少缓存的字节数
skip(long n) 跳过几个字节读取
多线程—>利用几个线程同时读取文件
10000字节 5个小人同时读取
1-2000 2001-4000 4001-6000 6001-8000 8001-10000
D当做服务器 E当做客户端
*close() 将流管道关闭—必须要做最好放在finally里注意代码的健壮性判断严谨

字节型文件输出流 FileOutputStream

将数据写入文件中

1. java.io
2.继承OutputStream 所有字节型输出流的父类
3.创建对象
调用一个带File参数还有File boolean重载
调用一个带String参数还有String boolean重载
4.常用方法

write(int code); 将给定code对应的字符写入文件 ‘=’
write(byte[]) 将数组中的全部字节写入文件 getByte()
flush(); 将管道内的字节推入(刷新)文件
close(); 注意在finally中关闭

字符型文件流

	FileReader	FileWriter
	只能操作纯文本文件(文件右键打开方式 记事本打开 能看懂)
	.txt

FileReader

1.java.io包
2.继承 InputStreamReader Reader
3.构造方法
4.常用
read()
read(char[])

FileWriter

1.java.io包
2.继承 OutputStreamWriter Writer
3.构造方法
带file参数带file,boolean参数
带String参数带String,boolean参数
4.常用

write(int)
write(char[])
write(string)
flush close

FileInputStream/FileOutputStream
FileReader/FileWriter
read write

缓冲流

	在流管道内增加缓存的数据
	让我们使用流读取的文字更加的流畅
	高级流--->创建通过低级流
	BufferedInputStream/BufferedOutputStream
	         BufferedReader/BufferedWriter

BufferedInputStream

构建方式  使用低级流构建
基本使用与低级流的方法完全一致
read()  skip()  available()  close()

BufferedOutputStream

构建方式  使用低级流构建   注意 缓冲流构建的时候没有boolean类型的参数
基本使用与低级流的方法完全一致
write()   flush()  close()
	

	数组  box  集合(List Set Map)--->做真实数据的存储
	都不好--->临时性的存储  都在内存中
	文件----->永久性的存储  存储在硬盘上

BufferedReader

		String value = readLine();

BufferedWriter

		write(String)
		newLine()\

对象流—将对象直接存入文件中

对象拆分成字节码直接写入文件

对象的序列化/反序列化
对象的序列化指的是 
	将一个完整的对象 拆分成字节碎片 记录在文件中
对象的反序列化指的是
	将文件中记录的对象随便 反过来组合成一个完整的对象
如果想要将对象序列化到文件中
	需要让对象实现Serializable接口
	是一个示意性接口
	同时为了让对象可以反序列化
	需要让对象中多存在一个属性  private long serialVersionUID = 任意L;
如果想要将对象反序列化
	需要给对象提供一个序列化的版本号  1.7版本-->String   1.8-->String

线程相关

程序  
	可以理解为是一组静态的代码  
进程  
	正在进行的程序	静态的代码  运行起来
线程
	正在执行程序中的小单元
eg:聚餐
聚餐之前   班级大扫除
扫除需要分配任务	任务写在纸上  列一个清单
一声令下   开始扫除    进程
每一个同学都做自己的事情   并发执行   互相不影响

线程区别
1.主线程系统线程
2.用户线程 main
3.守护线程(精灵) GC

线程------操作系统级别 CPU
如何在Java中创建线程让线程执行多线程
掌握每一个线程的几种不同状态及状态之间如何切换

new         start()       CPU分配run()       wait()	   exception  over
创建线程------就绪状态------执行状态------等待/挂起------异常/消亡
                |                              |
                |______________________________|
	                    notify/notifyAll

继承Thread 实现线程的过程
1.自己描述一个类
2.继承父类Thread
3.重写run方法
4.new一个线程对象调用start()方法让线程进入就绪状态
实现Runnable 实现线程的过程
1.自己描述一个类
2.实现一个父接口Runnable
3.重写run方法
4.new一个线程对象需要创建Thread将自己的对象包起来然后调用start()

模拟一个火车站售票小例子
1.车票 2.系统12306 3.窗口window 多线程

车票
属性
起始站
终点站
票价
系统
属性
集合
方法
窗口
是一个线程
利用Vector集合集合本身就是线程安全
1.如何切换线程的不同状态
2.如果在设计中没有集合我们自己想要控制线程安全

网络通信

反射与注解

GUI Swing(画窗口页面)

Rro_aa

关注

4
点赞
踩
35

收藏

觉得还不错? 一键收藏
0
评论
java常见类——工具类

目录工具类Java开发者写好的类---官方文档 API包装类(封装类)数学相关Math类Random类UUID类BigInteger类BigDecima类超过了double取值范围DecimalFormatScanner类System类日期相关Date类DateFormat类Calendar类 1.1版本TimeZone字符串String类---->引用类型 java.lang包StringBuffer和StringBuilder知识总结集合相关（ArrayBox LinkedBox
复制链接

扫一扫