JavaSE学习笔记部分内容的前部分资料

Object类
是类层次结构的根类.                                                                                       
toString: 返回该对象的字符串表示

getClass: 返回一个字节码对象

Integer.toHexString():将int整型数字转换为十六进制字符串
   
hashCode:获取hash值(通过内部地址转换成一个整数在转换为十六进制数)
获取字节码的方式
通过Object类的getClass()方法获取
  示例:Class clazz = student.getClass();
类名.Class属性
  示例:Class clazz = student.Class;
Class类的静态方法forName()来获取
  示例:Class clazz = Class.forName(),需要抛出异常
    推荐使用的三种方式:包含了全路径的类名   
注意:同一个类的字节码对象只有唯一的一个,代表这个类
epuals方法的含义:
boolean epuals()使用==来比较两个对象是否相等,则比较地址值是否相等
System类的概述
  System类包含一些有用的类字段和方法.他不能被实例化.
常用的静态方法
复制数组
        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)                                                                                                
   Object:数据源和目的地
   
   src:源数组
   
   srcPos:指定从那个索引位置开始复制
   
   dest:目标数组
   
   destpos:指定目标数组接收元素的索引位置
   
   length:目标数组接收元素的个数
返回当前系统时间
  static long currentTimeMillis()  
终止虚拟机的运行                          
  static void exit(int status)                          
                           
Date类的概述和构造
构造方法:
  Date();创建的时一个表示当前系统时间的Date
  Date(long date):根据"指定时间"创建Date对象
Date类的常用方法
毫秒值----Date
  设置:返回值是void,参数long
Date----毫秒值
  获取:返回long,无参数 long getTime()
Simple Date Format类概述
格式化: Date---String
  2049-8-6   2049年8月26日
解析: String----Date

构造方法:
  Simple Date Format():使用默认的模式进行对象的构建
  Simple Date Format(String pattern):使用的指定的时间进行对象的构建
   注意:解析的字符串,模式必须和构建对象的模式一样
Calendar的概述和测试
日历,提供了一些年月日的方法
获取
年:int year = c.get(年);     
月:int month = c.get(yue);
日:int day = c.get(日);
DAY_OF_MONTH
修改
void set(int field, int value) : 将给定的日历字段设置为给定值
int get(int field):返回给定日历字段的值
增加
void add(int field, int amount) : 为给定的日历字段添加或减去指定的时间量, 如时间字段是
天, 增加n天, 时间字段是秒, 增加n秒. 减少用负数                           
包装类的常用方法
需求：判断一个数是否符合int类型的范围
由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供了包装类
包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量
  byte  Byte
     short     Short
     char  Character
     int   Integer
     long  Long
     float  Float
     double  Double
     boolean  Boolean
  -------------------------------------------------------------------------------------------------------------------------------------
  Integer:
   String --- int
    方式1：int intValue()
   方式2： static int parseInt(String s)
   int --- String
   方式1： + ""
   方式2：String toString()
构造方法：
    Integer(int value)
    Integer(String s)
包装类的自动装箱与拆箱
自动拆箱：对象转成基本数值
动装箱：基本数值转成对象
正则表达式
正则表达式概述
  正则表达式：就是一套规则，可以用于匹配字符串
  boolean matches(String regex) ：判断当前字符串是否匹配指定的正则表达式，如果匹配则返回true，否则返回false
  
----------------------------------------------------------------------------------------------------------------
/*
  切割字符串"aa,bb,cc";
  切割字符串"-1 99 4 23";
  切割字符串"-1   99 4     23";
  
  ring[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
*/
public class RegexDemo3 {
public static void main(String[] args) {
  //method();
  //method2();
  String s = "-1   99 4     23";
  String[] arr = s.split(" +");
  print(arr);
  
}
private static void method2() {
  String s = "-1 99 4 23";
  String[] arr = s.split(" ");
  print(arr);
}
private static void method() {
  String s = "aa,bb,cc";
  String[] arr = s.split(",");
  print(arr);
}

public static void print(String[] arr) {
  for (int i = 0; i < arr.length; i++) {
   System.out.println(arr);
  }
}

=======================================================================================

第六天的笔记
ArrayList:
  集合的体系结构:
    由于不同的数据结构(数据的组织,存储的方式),所以java为我们提供了不同的集合,
    但是不同的集合他们的功能都是相似,不断的向上抽取,将共性抽取出来,这就是集合的体系
  体系结构:                       
  怎么学习?最顶层开始学习，因为最顶层包含了所有的共性
  怎么使用？使用最底层，因为最底层就是具体的实现
迭代器:
集合的遍历方式：
   1.toArray(),可以把集合转换成数组，然后遍历数组即可
    2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
    Iterator：可以用于遍历集合
    E next()  :返回下一个元素
    boolean hasNext()  ：判断是否有元素可以获取
注意：Exception in thread "main" java.util.NoSuchElementException
    使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException
并发修改异常:
  需求：判断集合中是否包含元素java，如果有则添加元素android
  Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
  迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常                 
解决方案:
  你就别使用迭代器
  在使用迭代器进行遍历的时候使用迭代器来进行修改
增强for&泛型
泛型的引入                          
  使用集合存储自定义对象并遍历
  由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，
  所以java为了解决这个问题，给我们提供了一种机制，叫做泛型
  泛型:是一种广泛的类型,把明确数据类型的工作提前到了编译时期,借鉴了数组的特点
  泛型好处
  避免类型转换问题
  减少警告
  简化代码书写
  作用:
   用于明确数据类型
   将运行时才发生的类型转换问题,提前编译时期
                           
增强for                           
作用:
  遍历数组和集合
格式：
  for(元素的数据类型  变量 : Collection集合or数组){
   可以直接使用变量;
  }
                          
  foreach:增强for循环，一般用于遍历集合或者数组
  注意：在增强for循环中不能修改集合，否则会出现并发修改异常。

public interface Iterable<T>
实现这个接口允许对象成为 "foreach" 语句的目标。
第3章 常见数据结构                        
数组: 查找快,增删慢;
链表: 可以说是一堆节点一个一个的连接起来的
结点: 地址值,值,下一个结点地址值可以理解为从1到N个数连接起来的
特点: 查询慢, 增删快.
栈: 栈&队列                          
栈的原理是先进后出;
队列的原理是先进先出,后进后出.
总结:栈和队列的出口不是一样的,栈的出口只有一个,队列的出口可以理解为有多个
第4章 List子体系

List子体系特点                          
A:有序的（存储和读取的顺序是一致的）
B:有整数索引
C:允许重复的
List的特有功能
   void add(int index, E element) :将元素添加到index索引位置上
E get(int index) :根据index索引获取元素
E remove(int index) :根据index索引删除元素
E set(int index, E element):将index索引位置的的元素设置为element

增删改查                     
                           
list的常用子类
ArrayList
  底层是数组结构，查询快，增删慢
LinkedList                          
  底层结构是链表，查询慢，增删快                        
LinkedList的特有功能：
  void addFirst(E e)  //将元素添加到索引为0的位置
  void addLast(E e)  //将元素添加到索引为size()-1的位置
  E getFirst()  //获取索引为0 的元素并返回
  E getLast()  
  E removeFirst()
  E removelast()                          
=========================================================================================                        
第七天的笔记                           
第1章 HashSet集合                           
set体系的特点                        
  A:元素(存入集合的顺序和取出集合的顺序不一致)
  B:元素不能重复(元素唯一)
  C:么有索引
  
HashSet唯一性原理                           
     使用HashSet存储自定义对象并遍历  
  通过查看源码发现：
   HashSet的add()方法，首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较，
   如果hash值不一样，则直接添加新的元素
   如果hash值一样，比较地址值或者使用equals方法进行比较
   比较结果一样，则认为是重复不添加
   所有的比较结果都不一样则添加
  Collections：
    面试题：Collection和Collections有什么区别？
    Collection是集合体系的最顶层，包含了集合体系的共性
    Collections是一个工具类，方法都是用于操作Collectio
                                                   
第2章 HashMap集合                           

Map 常用功能                           
映射功能：
  V put(K key, V value) :以键=值的方式存入Map集合
获取功能:
  V get(Object key):根据键获取值
  int size():返回Map中键值对的个数
判断功能：
  boolean containsKey(Object key):判断Map集合中是否包含键为key的键值对
  boolean containsValue(Object value):判断Map集合中是否包含值为value键值对
删除功能:
  V get(Object key):根据键获取值
  int size():返回Map中键值对的个数
遍历功能:
  V get(Object key):根据键获取值
  int size():返回Map中键值对的个数
                        
2.3 Map的两种遍历方式                           
2.3.1 利用keySet()方法遍历                           
   Map的第一种遍历方式：
    首先召集所有的丈夫
   遍历所有的丈夫
    获取每一个丈夫
    让每一个丈夫去找他自己的媳妇
                           
2.4 可变参数                           
当参数不确定的时候, 类型要明确
Java可以把多个参数直接帮我们转成数组
理解: 可变参数本质就是一个长度可变的数组.
格式:
  实参: 一个参数一个参数的传递
  形参: 类型…变量名
注意                        
  在可变参数之后不可以再追加参数
  参数的数量定义, 可以给多个甚至也可以一个都不不给
  
========================================================================================                       
第八天的笔记                           
第08天 异常                          
Throwable常用方法&自定义异常                           
  Throwable的常用方法：
   String getMessage()  
   String toString()  
   void printStackTrace()  
  
finally的概述和应用场景                        
finally使用格式:
   try{
   
   }catch(异常类型 异常变量){
   
   }finally{
      //释放资源的代码
   }
                          
异常的分类:
  运行时期异常:运行时期异常:RuntimeException的子类就是运行时期异常，在编译时期可以自由选择处理或者不处理
编译时期异常
  是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理

throws:处理异常的一种方式,把异常抛出,由调用者来处理                     
  throws:制造异常的方式,并且结束方法

注意：如果抛出（throw）的是编译时期异常，必须在方法声明处抛出（throws）

如何自定义一个异常类呢？
  非常简单，写一个类去继承Exception或者RuntimeException，然后实现多个构造即可
递归的概述                        
  * 需求：求5的阶乘
  5! = 5 * 4 * 3 * 2 * 1;   //120
   5! = 5 * 4!;    //120
    4! = 4 * 3!;   //24
     3! = 3 * 2!;  //6
      2! = 2 * 1!; //2
      1! = 1;     //1
n! = n * (n - 1)!

递归：把大问题拆成很多小问题，然后再把小问题拆成更多的小问题，
   当我们把更多小问题解决了，小问题也解决了
    随着小问题的解决，大问题也随之解决了
在方法本身不断的调用方法自己

递归注意事项：
   递归一定要有出口，内存溢出
   递归次数不宜过多，内存溢出
                     

我来占层楼啊