常用API
Object 里的 toString 和 equals ;
获取字节码对象 的方式
1 通过Object类的getClass()
2 通过类名调用属性 class 来获取
3 通过class类的静态方法 forName() 来获取
arrayCopy(); 复制数组
=================================================
Object // System
Object 是类层次结构的根类 任何类都继承了Object
默认父类为Obj
toString
tostring--- --- 返回对象的字符串表示形式；；；；；
有静态 可以 通过类名来使用
输值出一个对象 就是默认输出这个对象的地址值
getclass(): 返回一个字节码对象
hashCode () 返回对象的（哈希马志）内部地质值
getName() 获取类的全名（包名.类名）
Inteager.toHexcString() 将int整形数字装换成十六进制数
重写toString “”
---
//字节码
获取字节码对象 的三种方式：
getClass();
类名.class 属性
Class.forName() ; 类的静态方法
==================
1 通过Object类的getClass()方法获取；
Class clazz = 对象.getClass();
2 通过类名调用属性Class 来获取
Class clazz = 类名.class;
3 通过类的静态方法forName()来获取
Class clazz = Class.forname(包名.类名){类的全名};{需要抛出异常}；
复制字符串 快捷方法、
定义类后 在类名 鼠标右键 Copy 复制路径
equals 方法；；；；；；；；；；；；；；；；；；；；；；；；；；；
引用类型比较的地址值
基本数据类型 比较的是值
在引用类型里 重写equals 比较数值
---
System类;
在java.lang包下 直接用
System 包含一些有用字段 和方法 不能被实例化
常用静态方法
可以直接用System 类名调用
1 static void arrayCopy(目标被复制数组，指定索引位置， 接受复制元素数组，接受复制元素位置， 接受数组接受长度 ) ; 复制源数组中指定长度个元素到一个新数组中；
2 static long currenTimeMillis() 返回当前系统时间的毫秒；范围是 从 1970.1.1.0.0.0 到现在的时间的毫秒值
3 System void exit(int status) 终止虚拟机的运行
=======================================
Date类 的概述和构造
是日期类 表示特定的瞬间 可通过方法来设定所表示的时间 可以表现任何时间
构造方法 ；
Date Date () 返回当前系统时间 的Date对象
Date Date (long date ) 创建Date对象 返回指定时间
成员方法
{常用的方法 ；
毫秒值 --- Date
设置
返回值是 void 参数 long
void setTime(long time)
Date --- 毫秒值
获取
返回long
long getTime();
}
String toLocalString() 转换为本地时间格式的字符串
========================================
SimpleDateFormat 类概述
可以创建对象 并同时指定格式
SimpleDateFormat SimpleDateFormat（String pattern）;
专门用于格式化和解析时间
（查看类 有无静态 有静态 用类名调用）或（用子类对象调用方法）
格式化（日期到文本）
Date -- --- - String
String format(Date date);
解析（文本到日期）{解析时 字符串模式必须和创建对象时的格式一致}
String --- -Date
Date parse(String string);
{1 创建模式对象 2 创建日期对象 3 转换 } {shift + alt+ m 封装方法}
星期是 （E）；
年月日 小窍门 ： yyyyy-mm-dd E HH : mm: ss:sss
==================================
---
Calendar的=概述和测试
Calendar c = Calendar.getInstance( );
int a = c. (Calendar.string)
Calendar . (年 、月、日、时)；
月份 数值是从0开始 要加1；
Calendar.set\get\add;
日历类
提供了一些操作年月日时的方法
获取
int get(int field);
修改
c.set ( );
添加
c.add( );
静态方法 ：
成员方法：
int get() 返回给定值
void set()
---
包装类
int 的范围 -2的31次方 到 2的31次方 减1；
概述和基本使用
封装了基本数据类型
包装类就是封装了基本数据类型的类 提供更多方法和变量
bayt Bayt
shart Shart
char Character
int Integer
long Long
flout Float
double Double
boolean Boolean
构造方法
Integer(int value)
Integer(String s)
Integer-------------------------
String ---- int ; (字符串 转int)
1 int value
2 static int parseint(String s);
int -------- String ;（int 转 字符串）
1 +“ ”；
2 String toString();
---
自动拆、装箱
JDK 1.5 的特性 自动装箱 自动拆箱
简化的方式 去直接 变量代码
装箱：
基本数据类型可以自动转换为包装类
拆箱：
包装类转换到到基本数据类
---
正则表达式
是一种用于匹配字符串的规则；
可用于判断是否符合某种规则 比如QQ 手机号码等......
boolean matches(String regex);;;判断当前字符串 是否匹配指定的字符表达式 匹配则true 否则false;;;;;
字符类：
[abs] （a，或b或c）简单类
Pattern类：
字符：
预定义字符：
String 类：
用方法：：
boolean matches (String regex);
Pattern{正则表达式的规则 在API 查询}；
Collection//////////////////
{String >>>>>>>>>SimpleDateformat>>>>>Date}{}
Class
获取字节码对象
String toString
Boolean equals(Object obj);
SimpleDateFormat :
格式化
Date --- String
String Format(Date date);
解析
String ----- Date
Date parse(String sous);
构造方法
SimpleDateFormat() 默认模式进行对象构建
SimpleDateFormat(String souse) 用指定模式进行对象构建
Collection -------------------------------
Iterator 迭代器
遍历数组 并可以用他的子类去对集合进行操作
迭代器和集合的依赖性较强 要对集合遍历并操作的话
可通过Iterator的子类进行遍历操作
泛型
<E> E 表示为可以添加数据的类型
Foreach 曾强For循环 Foreach(元素的数据类型 ：集合或数组的对象 ){直接使用 }
Foreach 就是迭代器的一种 在for中不能对集合进行修改 会引发并发修改异常
常见数据结构
数组
数组的长度已经定义 不可改变
数组中元素都有索引值
数组只能存储同一类型元素
数组既可以存储基本数据类型 也可以存储引用数据类型
元素的获取
通过索引 获取元素 arr[6];
//添加新元素
创建新数组 长度为原数组长度加一
遍历原数组 并将元素插入到新数组中；
当遇到元素3时 在元素3 的后面添加新元素8
然后把剩余元素添加到新元素的后面即可；
数组特点 查找快 增删慢；
不同数组长度 添加元素时 需要错位；
链表
链表 ： 由链子连接起来的一堆接点
结点 ： 地址值，值，下一个结点地址值；
1,2,3,4,5
获取结点
遍历链表 挨个查看
添加新结点
把要添加新结点的前一个结点的下一个结点地址值修改为新结点的地址值
然后把新节点的下一个结点地址值改为后面结点的地址值；
链表特点
查询慢 增删快
栈
特点
先进后出 进 1，2，3 出 3,2,1；
队列
特点
先进先出 进 1,2,3 出 1,2,3
超级接口 Collection / Iterable @ @
= () =
List 是 Collection 的子体系
List 特点
有序的（存储和读取顺序一致）；
有整数索引；
允许重复；
List 特有功能
增删改查
Void add(int index,E element);
E remove(int index);
E set(int index , E element);
E get(int index);
ArrayList
底层是数组结构 查询快 增删慢
LinkedList
底层是链表 查询慢 增删快
使用场景
查询多 增删少 用ArrayList
增删多 查询少 用LinkedList
查询 增删 差不多 用ArrayList
LinkedList 特有功能
get add remove
Void addFirst(E e);
Void addLast(E e);
E getFirst()
E getLast();
E removeFirst();
E removeLast();
/////////////////////////////////
HashSet
特点
无序（存储和读取的顺序可能不一样）
不允许重复
没有索引
===============================
ArrayList
数据结构不同 提供了不同的
集合本身存的就是Object 对象
集合的体系结构
从最顶层开始学习 顶层包含了所有共性
【boolean add(E e) 】增
【booelean remove( ); 】 删
【void clear( ); 】 清空集合；
【 int size 】 长度
【Object [] toArray () 】 转换成数组 然后遍历数组 ；；
【isEmpty ()】 检测集合是否为空
=============
Iterator--：迭代器
面向对象使用 遍历集合
Iterator <E> iterator;() fan方法‘
成员方法
boolean hasNext() 是否有下一个元素
next() 返回下一一个元素
void remove 去除指向Collection 的最后一个元素
迭代器是依赖集合的 想当于集合副本
要修改集合 通过迭代器去进行操作 用 其子类方法；；；
一个集合对应一个迭代器 方法；；；；
调用 ListIterator 中的方法 可对集合进行操作；
并发修改异常 --====指的是会改变集合 长度的操作 会引发 ；
循环遍历 输出 while(){};
========================
Iterator接口
一个集合对应一个他本身特有的迭代器
在使用迭代器时 修改集合 会引发并发修改异常
{不用迭代器 或者 在迭代器里进行对集合的操作}
---
泛型（<E>）
在编译时期 检测代码 是否符合要求；
集合可以存储任意类型的对象 当存储不同类型对象，就可能在转换时出现类型转换异常；；；；；；；；；；；；；
泛型 避免了类型转换的问题 简化代码书写 减少黄色警告；
有<E>就可以使用泛型；；；；
作用 ：
明确数据类型 ，，，，将运行时发生的类型转换提前到了编译时期；；；
泛型只是安全检测机制 只在编译时有效
党员代码yiweiclass文件后 代码不存在泛型
泛型位置：
类
接口
方法
成员方法： public <C> C eat (C c) {} \返回泛型对象；
静态方法只能使用自己的泛型；
'''''''''''''''''''''''''''foreach'''''''''''''''''''''''''''
曾强for循环
作用 ：：---遍历数组和集合；；；
for( 元素的类型 变量名 ： 集合或数组的对象){
任意使用变量。。。。。。。。。。。。。。。}
实用环境：----内部用的是迭代器 性质一样；
=============================
数组：：
ArrayList 的底层是数组：
查询快 增删慢
链表：
有链子连结起来的一堆结点；
结点格式 ； 地址值 ， 值， 下一个结点地址值
LinkedList 的底层是链表；
获取结点 只能遍历；挨个查看；；
增删快 查询慢；；
链表 和 数组 根据需要 调用；；
栈 队列：：
特点：：：
栈 ： 先进后出 （FILO ,First in Last Out）;
队列： 先进先出；（FILo）;
---
List（体系）类的特点和功能：
List 接口：
对每个元素进行精准控制，
特点：
有序的 ； 有整数索引； 允许重复；；；；
List 功能：
增-------------void add(int index , E element);
删--------------E remove(int index);
改----------------E set(int index , E element); 将指定位置元素修改 并返回被修改元素；
查---------------E get(int index);
继承自Collection
List 的常用子类：
ArrayList 集合
底层是数组结构 查询 快 增删慢；
LinkedList 集合
底层是链表结构 查询慢 增删快；
选择集合：
查多 用 ArrayList
增删多 用LinkedList
LinkedList ------
特有功能：
First（开头）
Last（末尾）
增-------add
删------remove
查--------get
异常的概述和体系结构
异常： 不正常 在写代码是出现的编译或者运行错误；【编译或运行时】
出现异常 虚拟机会帮我们创建异常对象，里面包含异常信息 异常对象里面包含了错误的类型 原因及位置；
{ArithmeticException}；；；
异常的体系机构 ：
Throwable（最顶层）；---有三个方法】
Error（出现的不能处理的严重问题）--在程序运行中；；
Exception（可以处理的问题）---编译时异常//运行时异常---编译正常 ， 运行时报错；
---
异常的处理方式【捕获异常】：
JVM默认的异常处理方式 ------ try{} catch(){};
手动处理异常的两种方式 ：
1 捕获异常并处理:
try ...catch语句；
【提前对可能发生的异常进行 处理 纠正错误并避免程序终止】
try{
} catch( ) {
}的.
执行顺序 ：
1 首先执行 try 语句
2 如果发现异常 异常下面的代码不再执行 直接跳入catch语句 catch结束后 整个 try.... catch 结束；
3 如果没有发现异常 try 结束后 整个 try...catch 直接结束 不在执行 catch语句；
用 关键字 throws 在方法的声明处抛出异常；；；
2 抛出去：
【直接抛出异常 在方法声明上添加【throws】异常类型】
---不捕获异常
当不想处理异常 或没能力处理异常的时候；谁调用方法 谁抛出异常---在方法声明上 表示该程序可能会出现异常；
在main 主方法中 Jvm虚拟机帮我们抛出异常
3 Jvm处理异常的方式：
如果出现异常 我们没有处理 Jvm 会帮我们处理异常 ：他会把异常的类型 原因 还有位置显示在命令行：
并且还终止了程序，异常后面的代码将不在执行；
====================================
如何处理多个异常：
【多个异常时 子类异常在上 父类异常在下】；
1 可以使用多个 try { } catch（异常对象）{ }语句；
2 可以使用一个 try{ } 多个 catch( ){ }语句;
【多个catch中间可以是子符类关系 子类在上 父类在下】
---
Throwable 的常用方法：
JvM和手动获取异常的区别： JVM --try执行结束后程序结束；手动获取异常 则可以执行后面代码；
通过对象 . 调用；
放在异常处理区；
//原因
String getMessage（）；
//类型和原因
String toString（）;
//类型原因和位置--将错误流打印到控制台；
void printStackTrace（）;--系统的标准错误输出流
自定义异常：
---
异常的分类：
1‘ RuntimeExceotion的子类就是运行时期异常 在 编译时期 可以自由选择处理或者不处理
2 编译时期异常： 是Exception的子类 非RuntimeExcption的子类， 在编译时期必须处理
【不处理没法运行】
====================
finally:
用于释放资源等收尾工作；无论try...catch
用于组合try{ } catch( ){ }语句
try{ 问题语句}catch(异常对象){
处理异常
}finally{
释放资源 ；
清理垃圾；
}l
finally ---------- 一定执行；
===========================
自定义异常【自己做异常】：
throws
处理异常的一种方式 把异常在方法声明处抛出 由调用者来处理；
throw
制造异常的方式 ， 并且结束方法；
运行异常 继承 RuntimeException;
编译异常 继承 Exception; --- 在方法声明 抛出（throws）；
写一个类去继承 RuntimeException // Exception 然后实现多个构造即可
---
捕获处理
try{
可能有问题的代码}catch(){
处理异常
}
Set（Collection的子类子 接口）接口
特点：
{数组的工具类 是arrays}
{List 四种遍历方法}
（父类引用指向子类对象 不能调用子类特有方法 ）
Set集合特点 ：
无序（存储和读取有可能不一样） ；
不允许重复 （要求元素唯一）{可利用set进行集合元素去重操作}；
没有索引；（可以转换成数组 进行需要索引才能进行操作的操作）；
使用HashSet存储字符串
{使用 ： 1 创建集合对象 2 创建元素对象 3 添加元素 4 遍历集合}；
三中遍历方法：
1 -- 数组
toArray
2---迭代器
3----曾强for
---
HashSet （是Set的实现类）（底层哈希表）的add()方法
首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较 ，
如果hash值不一样 则直接添加新的元素；
如果 hash值一样 则比较地址值 或者使用equals方法进行比较；
比较结果一样 则认为是重复不添加
所有的比较结果都不一样则添加；；
---
hashSet 重写equals 和Hascod 方法 去除重复添加；
---
hashCode方法 和 equals方法的优化：
让hashCode返回值和对象的成员变量有关 ---- 成员变量不同的 对象 hashCode返回值值不同；
可以让hashCode方法返回所有成员变量之和：
让基本数据类型直接相加 引用数据类型获取hashCode值后再相加 （boolean不可以参加运算）；
================提高程序运行效率，，，
this == 对象；
……^ 安全性；
this.getclass .equals(对象.getclass());
加一个判断字节码的语句^^^^^ 健壮性^^^^^
---
Collections （都是静态 可以直接调用） 工具类‘’
和Collection的区别：
Collection 是集合体系的最顶层 包含了集合体系的共性
Collections 是一个工具类 方法都是用来操作Collection；
方法----
{将基本数据类型 包装成引用类型}
1 static int binarySearch(List list , T key);
使用二分查找法 查找指定元素 在指定列表的索引位置；
使用前提 数据有顺序，（set 无序 不可以 Collection 也不行）---参数就得是List！！！！！！！
集合只能存对象；
自动装箱——————直接添加元素到集合；
2 static void copy(List dest , List src);
把源列表数据覆盖到目标列表
《（目标列表长度至少必须等于源列表）源列表大于等于它的长度》
3 static void fill(List list , object obj)
使用指定的对象填充指定列表的所有元素
4 static void reverse(List list ): 反转；；
5 static void shuffle(List list): 随机置换
6 static void sort {不是能排所有的元素 必须要有自然顺序} (List <T> list) : 按照列表中元素的自然顺序排序；；；
7 static void swap (List list , int i ,int j): 将指定列表中的索引进行位置互换；
操作一个对象 返回void 说明对象本身发生了变化
{操作一个对象 返回新对象 一般说明对象本身不会变化 }
void ------ 对象变了
有对象 有具体返回值 ------对象没变化；
====================================
**模拟斗地主发牌：
{数组 或集合 作为牌数据的存储对象 利用取余来获取纸牌分发对象集合 然后遍历输出}
创建集合 接受数据 创建数组 匹配组合数据
利用集合Collections 工具类 中随机方法 进行发牌输出 ；
创建几个集合 接受数据 然后输出
for (){} \String [] arr \ Collections 工具类
=================================
Map （双列集合的顶层）接口
Map< K , V >------Key 不可以重复的键；Value 可以重复的值；
如果Key重复 Value 被覆盖；
专门用来存储对应关系的集合 Map;
特点：
Map 将建映射到值的对象 。。一个映射不包含重复的键 ；每个键最多只能映射到一个值；；
Map 和Collection的区别：
Map : 是一个双列集合 ，常用于处理有对应关系的数据；Key 是不可以重复的 俗称“夫妻对集合”；；
Collection : 是单列集合 ， Collection 有不同的子体系，有的允许重复··有索引··有序；；
有的不允许重复····且无an序------“俗称单身汉集合”
【实现学号和学生姓名有对应关系的数据存储，，，，
一对一 ： 一个学号对应一个姓名； 】
Map的常用功能：{
方法和功能
添加
映射功能————V put(K Key , V value);---将K映射到Value的功能；如果Key存在 则覆盖value 并将原来Value 返回 如果Key不存在则返回 null;;;;
删除2
void clear() 请空集合所有对应关系；；
V remove(Object key) 删除 指定的值 删除成功则返回被删除的Value 值 没有则false;
判断2
boolean containsKey(Object Key ) -------- 检测集合内的Key部位 有没有指定数据 有则true 没有则false
boolean containsValue(Object value)---------- 检测集合内的Value有没有 指定数据 有则true 没有则false
boolean isEmpty(); 判断 集合有没有对应关系 有则返回 false----- 没有则----true ;
遍历
Set<Map.Entry<K,V>> entrySet();
获取
V get(Object key); 返回指定Key的Value值；
int size(); //集合长度
================
Map的 获取所有的方法
Set<K>keySet();-------获取所有的 Key -- 一Set的形式 返回所有的 Key; Set 不重复;
Collection<V> values();----获取所有的Value ----- Collection 的形式 返回所有的Value;;;
Value 返回的是一个允许重复的集合 但不是List 不能强转成List;;;;
===========================================
Map 的遍历 一
先获取Key 然后遍历
对象 . Keyset（）；
然后同过Key 获取Value
最后输出 集合
---
Map 的第二种遍历：
Entry 是Map的内部类；
获取【【Entry】】对象
//Map 是修饰Entry的
Set<Map.Entry<String , String>> entry = 对象 . entrySet();
---
HashMap 存储数据并遍历------
Key作为字符串 可以在添加元素时 去重；；；
HashMap 存储数据并遍历------------
自定义对象为Key ;;;;
===========================
可变参数：：
当参数不确定时 类型要明确 JAVA 可以帮我们吧多个参数直接转成数组
形参： 类型...变量名
实参： 一个参数一个参数的传递
虚拟机会帮忙把参数转成数组；；；；
注意：
在可变参数之后不可以追加参数；（但是可以在前面追加参数）
参数的数量自定义 可以给对个 也可以一个都不给；
【【【方法重载 和方法的参数类型，参数位置，和参数名有关 其他无关；；】】】
|
|
收藏
淘帖
踩
