A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Pisces_Tiger

  • 黑马币:59

  • 帖子:43

  • 精华:0

© Pisces_Tiger   /  2017-4-3 21:34  /  3480 人查看  /  57 人回复  /   6 人收藏 转载请遵从CC协议 禁止商业使用本文

好好加油  希望你能一直坚持下去 到就业班毕业
回复 使用道具 举报
java.lang.Object 所有类的超类
  Object类中的方法子类都有
  
   Object类中
  public String toString()  返回对象的字符串表现形式  数据类型 + @ + 地址值(哈希值)
   子类一般都会重写此方法,因为看地址值没有意义,一般都需要看对象的属性值,返回属性值。
java.lang.Object
  
  boolean equals(Object obj) 比较两个对象是否相等  Object类中 比较的是地址值
   子类一般都会重写此方法 不再比较地址值,而是比较属性值。
  
   
   注意:不是所有的运算符都可以操作引用数据类型
     ==可以比较引用数据类型,但是==永远比较地址值
throw关键字  抛出异常
       定义在方法内  后跟异常的对象
  编译时异常 ( checkedException必须处理 两种方式 下面会讲到)
                编译期报错 必须处理 两种方式都可以
  运行时异常 uncheckedException 可以不处理)
                编译期不报错,运行时报错 可以处理 也可以不处理 推荐不处理
                因为如果出现运行时异常,一般情况都是代码有问题 ,需要修改代码
                如果出现运行时异常 程序中断 ,下面代码不会执行。
  
  异常处理的第一种方式  声明异常
  
  throws关键字 声明异常
       定义在方法的声明上  后跟异常的类名
  
  声明异常的细节
                可以声明多个异常 多个异常用,隔开
                如果想写的方便,可以声明抛出多个异常的共同父类
第二种异常的处理方式
  try{
        可能出现异常的代码
  }catch(异常的类名  变量名){
       代码块中写什么不重要,只要执行了catch代码块 就处理了异常
       一般情况都会打印异常的信息
  }finally{
        必须执行的代码
  }
catch处理异常
try{
  
}catch(异常的类名  变量名){
  
}catch(异常的类名  变量名){
  
}catch(异常的类名  变量名){
  
}....
  
  
  catch处理异常的细节
                多个异常有没有顺序?
                         没有直接的继承关系时,没有顺序
                         NullPorterExceptionextends RuntimeException
                           ArrayIndexOutOfBoundsExceptionextends IndexOutOfBoundsException extends RuntimeException
                           如果有直接的继承关系  有顺序  小的写在前面  越大的越往后放
                         ArrayIndexOutOfBoundsExceptionextends IndexOutOfBoundsException extends RuntimeException  extends Exception
                可以直接抓一个Exception 别的都可以不写
try{
       return i;
}catch(){
  
}finally{
       ++i;
必须执行的代码(无论是否出现异常 ,无论是否捕获异常 ,都会执行)
  }
1. 此时返回的i值不变 不是++i的值
2. 方法中已经出现返回语句返回值A,再在finally中修改A值,则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了
3. 当执行return结束方法,这时发现有finally没有执行,将返回的结果保存起来,再次执行 finally,执行finally之后,将保存的结果返回
异常后 方法重写的细节 (这里的抛异常指声明异常 第一种方式)
  
       如果父类方法有异常 子类方法需不需要抛异常
                         子类方法可以不抛异常
                         子类方法可以抛异常,但是一定要小于等于父类的异常
  
       如果父类方法不抛异常,子类需不需要抛异常
                         子类不可以抛异常  如果子类里边有异常 只能tryCatch处理
Throwable的三个方法
  异常信息
        String getMessage()    "文件没找到"
        String toString()       java.io.FileNotFoundException: 文件没找到
        voidprintStackTrace()  打印异常的详细信息
继承Exception 编译时异常
  继承RuntimeException运行时异常
  写构造方法即可
  自定义异常的使用和正常java提供的异常没有任何区别  java提供的异常怎么处理
  自定义异常就怎么处理
常见RuntimeException
//ArrayIndexOutOfBoundsException
//NullPointerException
// ClassCastException
// ArithmeticException

回复 使用道具 举报
http://sdual.boxuegu.com/
java.util.Date
  时间原点  1970-1-1 00:00:00
  构造方法
                public Date() 返回当前时间的日期
                public Date(毫秒值) 返回指定时间的日期对象 参数毫秒值 指的是从1970 1 1 经过的毫秒值
  方法
                long  getTime() 获取时间的毫秒值 1970 日期对象的所经历的毫秒值
                void setTime(long 毫秒值) 设置当前对象的毫秒值
java.text.DateFormat 日期格式化类  抽象类
SimpleDateFormat  extendsDateFormat
  构造方法
public SimpleDateFormat()  默认的格式  17-4-21 上午9:07
public SimpleDateFormat(String s) 给定的格式
  
  日期转换为指定格式的字符串
  String format(Date date)
  将指定格式的字符串转换成日期
         Date parse(String source)
//将日期解析成指定格式的字符串
Date date = new Date();
DateFormat df = newSimpleDateFormat(“yyyy.MM.dd  一年中的第D E”);
String str = df.format(date);
//将指定格式的字符串解析成日期
String str2 = “1999-01-10”;
DateFormat df2 = newSimpleFormat(“yyyy-MM-dd”)
Date date2 = df2.parse(str2);
java.util.Calendar 日历类 抽象类
  创建对象的方法
                static Calendar getInstance() 返回的是当前日历
  方法
                int    get(int i) 返回给定字段的时间
           void add(int field, int amount) 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
                Date getTime()  将日历对象转换为日期对象
                void set(int field, int value) 将给定的日历字段设置为给定值。
                void set(int year, int month, intdate)  直接设置年月日
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
long time = cal.getTimeMillis();
cal.add(Calendar.YEAR,-1);
cal.add(Calendar.DATE,1);
//数字0-11 代表 1-12
c.set(Calendar.MONTH,11);
//1999910
c.set(1999,08,10)     
自动拆箱装箱
                  Integer i1 = new Integer(500);
                   Integeri2 = new Integer(500);
                   System.out.println(i1== i2);//false
                   System.out.println(i1.equals(i2));//true
                  
                   Integeri3 = 500;//new Integer(500);
                   Integeri4 = 500;//new Integer(500);
                   System.out.println(i3== i4);//false
                   System.out.println(i3.equals(i4));//true
                  
                   //byte常量池细节 当值在-128 127之间时 会出现
                   //先判断有没有这个值 如果没有 则创建对象 如果有 ,直接赋值
                   Integer i5 = 127;//new Integer(100)
                   Integer i6 = 127;//i6 = i5;
                   System.out.println(i5 == i6);//true
                   System.out.println(i5.equals(i6));//true
                  
java.util.Arrays 数组工具类  方法都是静态
  
static void sort(int[] a)  数组排序
static String toString(int[] a)       返回数组的字符串表现形式  int[] arr = {3,8}
                                                                                 [3, 8]
java.lang.System 系统类 不可以创建对象  所有方法全部都是静态
  
   静态方法
     static void exit(int status) 终止虚拟机  0
     static void gc() 暗示垃圾回收器回收垃圾
     static String getProperty(String key) 获取系统属性
                            System.getProperty(“java.home”);
                            System.getProperty(“java.version”);
                            System.getProperty(“os.name”);
                            System.getProperty(“os.version”);
         staticvoid arraycopy(Object src, int srcPos,
                                            Objectdest, int destPos, int length)
获取当前时间毫秒值
  
  1.DategetTime()
  2.Calendarlong getTimeInMillis()
  3.Systemstatic long currentTimeMillis()
static void arraycopy(Object src, int srcPos,
                                            Objectdest, int destPos, int length)
Object src:要复制的数组数据源
  intsrcPos:从数据源中的第几个索引开始复制
Object dest:要讲数据复制到的数组  数据目的
  intdestPos:复制的数据放入到目标数组的开始索引
  intlength:复制几个
  
int[] score = {3,8,2,5,0};
数学工具类  java.lang.Math
static int abs(int a)  返回绝对值
static long round(double a)  四舍五入
static int round(float a)
static double ceil(double a)  向上取整
static double floor(double a) 向下取整
static int max(int a, int b) 两个数最大值
static int min(int a, int b) 两个数最小值
static double pow(double a, double b)  ab次幂
[] 代表 其中任选一个
  ?0-1
  * 任意次
  + 至少1
  {n}代表 出现n
{n,}代表至少出现n
{n,m}代表出现 n - m

回复 使用道具 举报
1111111111111111111111111
回复 使用道具 举报
java.lang.Object 所有类的超类
   Object类中的方法 子类都有

   在Object类中
   public String toString()  返回对象的字符串表现形式  数据类型 + @ + 地址值(哈希值)
   子类一般都会重写此方法,因为看地址值没有意义,一般都需要看对象的属性值,返回属性值。

java.lang.Object类

   boolean equals(Object obj) 比较两个对象是否相等  在Object类中 比较的是地址值
   子类一般都会重写此方法 不再比较地址值,而是比较属性值。


   注意:不是所有的运算符都可以操作引用数据类型
      ==可以比较引用数据类型,但是==永远比较地址值

throw关键字  抛出异常
          定义在方法内  后跟异常的对象
  编译时异常 ( checkedException必须处理 两种方式 下面会讲到)
                  编译期报错 必须处理 两种方式都可以
  运行时异常 (uncheckedException 可以不处理)
                  编译期不报错,运行时报错 可以处理 也可以不处理 推荐不处理
                  因为如果出现运行时异常,一般情况都是代码有问题 ,需要修改代码
                  如果出现运行时异常 程序中断 ,下面代码不会执行。


  异常处理的第一种方式  声明异常

  throws关键字 声明异常
          定义在方法的声明上  后跟异常的类名

  声明异常的细节
                  可以声明多个异常 多个异常用,隔开
                  如果想写的方便,可以声明抛出多个异常的共同父类

第二种异常的处理方式
  try{
           可能出现异常的代码
  }catch(异常的类名  变量名){
          代码块中写什么不重要,只要执行了catch代码块 就处理了异常
          一般情况都会打印异常的信息
  }finally{
           必须执行的代码
  }

多catch处理异常
  try{

  }catch(异常的类名  变量名){

  }catch(异常的类名  变量名){

  }catch(异常的类名  变量名){

  }....


  多catch处理异常的细节
                  多个异常有没有顺序?
                          没有直接的继承关系时,没有顺序
                          NullPorterException extends RuntimeException
                        ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException
                        如果有直接的继承关系  有顺序  小的写在前面  越大的越往后放
                          ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException extends RuntimeException  extends Exception
                  可以直接抓一个Exception 别的都可以不写

try{
          return i;
  }catch(){
  
  }finally{
          ++i;
必须执行的代码(无论是否出现异常 ,无论是否捕获异常 ,都会执行)
  }
1. 此时返回的i值不变 不是++i的值
2. 方法中已经出现返回语句返回值A,再在finally中修改A值,则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了
3. 当执行return结束方法,这时发现有finally没有执行,将返回的结果保存起来,再次执行 finally,执行finally之后,将保存的结果返回


异常后 方法重写的细节 (这里的抛异常指声明异常 第一种方式)
  
          如果父类方法有异常 子类方法需不需要抛异常
                          子类方法可以不抛异常
                          子类方法可以抛异常,但是一定要小于等于父类的异常
  
          如果父类方法不抛异常,子类需不需要抛异常
                          子类不可以抛异常  如果子类里边有异常 只能tryCatch处理

Throwable的三个方法
  异常信息
           String getMessage()    "文件没找到"
           String toString()       java.io.FileNotFoundException: 文件没找到
           void printStackTrace()  打印异常的详细信息

  继承Exception 编译时异常       必须处理(上面的两种方式)
  继承RuntimeException 运行时异常      可以不处理
  写构造方法即可
  自定义异常的使用和正常java提供的异常没有任何区别  java提供的异常怎么处理
  自定义异常就怎么处理

常见RuntimeException
//ArrayIndexOutOfBoundsException
//NullPointerException
//        ClassCastException
//        ArithmeticException


回复 使用道具 举报
本帖最后由 Pisces_Tiger 于 2017-5-2 10:39 编辑

java.util.Date
  时间原点  1970-1-1 00:00:00
  构造方法
                  public Date() 返回当前时间的日期
                  public Date(毫秒值) 返回指定时间的日期对象 参数毫秒值 指的是从1970 1 1 经过的毫秒值
  方法
                  long  getTime() 获取时间的毫秒值 从1970到 日期对象的所经历的毫秒值
                  void setTime(long 毫秒值) 设置当前对象的毫秒值

java.text.DateFormat 日期格式化类  抽象类
  SimpleDateFormat  extends DateFormat
  构造方法
  public SimpleDateFormat()  默认的格式  17-4-21 上午9:07
  public SimpleDateFormat(String s) 给定的格式

  日期转换为指定格式的字符串
   String format(Date date)
  将指定格式的字符串转换成日期
            Date parse(String source)
//将日期解析成指定格式的字符串
Date date = new Date();
DateFormat df = new SimpleDateFormat(“yyyy.MM.dd  一年中的第D天 E”);
String str = df.format(date);
//将指定格式的字符串解析成日期
String str2 = “1999-01-10”;
DateFormat df2 = new SimpleFormat(“yyyy-MM-dd”);
Date date2 = df2.parse(str2);

java.util.Calendar 日历类 抽象类
  创建对象的方法
                  static Calendar getInstance() 返回的是当前日历
  方法
                  int        get(int i) 返回给定字段的时间
              void add(int field, int amount) 根据日历的规则,为给定的日历字段添加或减去指定的时间量。
                  Date getTime()  将日历对象转换为日期对象
                  void set(int field, int value) 将给定的日历字段设置为给定值。
                  void set(int year, int month, int date)  直接设置年月日

Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
long time = cal.getTimeMillis();
对当前日期减一年
cal.add(Calendar.YEAR,-1);
对当前日期加一天
cal.add(Calendar.DATE,1);
//数字0-11 代表 1-12月
c.set(Calendar.MONTH,11);
//1999年9月10日
c.set(1999,08,10)     
自动拆箱 装箱
                Integer i1 = new Integer(500);
                Integer i2 = new Integer(500);
                System.out.println(i1 == i2);//false
                System.out.println(i1.equals(i2));//true
               
                Integer i3 = 500;//new Integer(500);
                Integer i4 = 500;//new Integer(500);
                System.out.println(i3 == i4);//false
                System.out.println(i3.equals(i4));//true
               
                //byte常量池细节 当值在-128 127之间时 会出现
                //先判断有没有这个值 如果没有 则创建对象 如果有 ,直接赋值
                Integer i5 = 127;//new Integer(100)
                Integer i6 = 127;//i6 = i5;
                System.out.println(i5 == i6);//true
                System.out.println(i5.equals(i6));//true
               

  java.util.Arrays 数组工具类  方法都是静态

  static void sort(int[] a)  数组排序
  static String toString(int[] a)         返回数组的字符串表现形式  int[] arr = {3,8}
                                                                          [3 , 8]附加方法:
   static int[] copyof(int[] original, int newLength)  复制指定数组  小于源数组长度截取 大于源数组长度 填充0
     类似方法 :system的静态arraycopy方法(下面讲到)   
   static asList(T... a)                         eg:     int[] arr = {3,8,2,5,0}
                      可变参数                                List<Integer> list = Arrays.asList(arr);
java.lang.System 系统类 不可以创建对象  所有方法全部都是静态

   静态方法
           static void exit(int status) 终止虚拟机  0
           static void gc() 暗示垃圾回收器回收垃圾
           static String getProperty(String key) 获取系统属性
                        System.getProperty(“java.home”);
                        System.getProperty(“java.version”);
                        System.getProperty(“os.name”);
                        System.getProperty(“os.version”);
        static void arraycopy(Object src, int srcPos,
                                          Object dest, int destPos, int length)
获取当前时间毫秒值
  1.Date类getTime()
  2.Calendar类long getTimeInMillis()
  3.System类static long currentTimeMillis()

system的静态arraycopy方法
static void arraycopy(Object src, int srcPos,
                                          Object dest, int destPos, int length)
  Object src:要复制的数组 数据源
  int srcPos:从数据源中的第几个索引开始复制
  Object dest:要讲数据复制到的数组  数据目的
  int destPos:复制的数据 放入到目标数组的开始索引
  int length:复制几个

int[] score = {3,8,2,5,0};

数学工具类  java.lang.Math
  static int abs(int a)  返回绝对值
  static long round(double a)  四舍五入
  static int round(float a)
  static double ceil(double a)  向上取整
  static double floor(double a) 向下取整
  static int max(int a, int b) 两个数最大值
  static int min(int a, int b) 两个数最小值
  static double pow(double a, double b)   a的b次幂

[] 代表 其中任选一个
  ? 0-1
  * 任意次
  + 至少1次
  {n}代表 出现n次
  {n,}代表至少出现n次
  {n,m}代表出现 n - m


回复 使用道具 举报
1.       知识点:泛型
要求:会使用泛型
泛型的好处是什么?泛型用于什么上?
泛型的好处:
                   1.提高了程序的安全性
                   2.将运行期遇到的问题转移到了编译期
            3.省去了类型强转的麻烦
    泛型的常见应用:
        1.泛型类
        2.泛型方法
        3.泛型接口
3. 请简述List<? extends T>List<? superT>之间有什么区别?
答案:
         List<? extends T> :向下限制
         List<? super T> :向上限制
        ?extends T : 代表接收的泛型类型为T类型或T子类类型
? super T :代表接收的泛型类型为T类型或T父类类型
java.util.Collection集合层次的根接口
  ArrayList implements List extends Collection
Collection接口中的内容 是共性内容  所有集合都具备
* 常用方法
* boolean add(E e)            //添加元素
* boolean remove(Object o)    //删除元素
* void clear()             //清空集合
* boolean contains(Object o)  //判断是否包含某元素
* boolean isEmpty()        //判断是否为空
* int size()               //获取集合长度
*Object[] toArray()           //将集合转换为数组
Collection使用迭代器遍历
  方法
      Iterator<E>iterator() 获取当前集合对象的专属迭代器
                             方法虽然是抽象的 但是Collection子类一定会重写返回Iterator的实现类对象 可以通过多态的方式获取到Iterator对象  使用Iterator的方法
  
  Iterator接口
   booleanhasNext()  判断是否有下一个元素
   Enext()      获取下一个元素  调用一次 取出一个元素
当迭代集合中元素时 ,使用集合对象 修改了集合的长度 会报此异常
* ConcurrentModificationException
看最后的eg2
while(it.hasNext()){
         String thisName = it.next();
         if("柳岩".equals(thisName)){
             集合c添加对象  改变集合长度 报异常
            c.add("大郎");
            集合不可以改变长度 但是迭代器可以
            it.remove();
         }
      }

含有泛型的类
定义格式:修饰符 class 类名<代表泛型的变量> {  }
使用格式:创建对象时,确定泛型的类型
n  例如,ArrayList<String> list = new ArrayList<String>();
含有泛型的方法
定义格式:修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }
       使用格式:调用方法时,确定泛型的类型
   public <MOMO> void method(MOMO mm){
      //MOMO类型在方法中可以使用
      System.out.println(mm);
   }
含有泛型的接口
定义格式:修饰符 interface接口名<代表泛型的变量> {  }
使用格式:
1、  定义类时确定泛型的类型
Public   class  MyClass4Interface implements MyInterface<String>{
@Override
   public voidmethod(String e) {
   // TODO Auto-generated method stub
   
   }
}
2、始终不确定泛型的类型,直到创建对象时,确定泛型的类型
public class MyClass24Interface<E> implements MyInterface<E>{
   @Override
   public void method(E e) {
      // TODO Auto-generated method stub
      
   }
}
=============================================================
eg1
list.add("aaa");
      list.add("ddd");
      list.add("bbb");
      list.add("ddd");
      list.add("ccc");
     
//      System.out.println(list.toArray());
      System.out.println(list);
      这里的删除是优先删除第一个
      list.remove("ddd");
      System.out.println(list);
==============================================================
eg2 list.add("aaa");
      list.add("eee");
      list.add("ddd");
      list.add("ccc");
      
      Iterator<String> it =list.iterator();
      
      while((it.hasNext())){
         String str = it.next();
         
//       concurrentmodificationexception异常
//       list.remove("ccc");
//       除了删除倒数第二个  其他位置的删除都异常
//       list.remove("ddd");
         System.out.println(str);
   如果删除最后一个元素  删除后 在此进入循环  it.next()时异常
   删除倒数第二个元素,删除后直接跳出循环
   删除其他位置的元素 ,删除后报异常

回复 使用道具 举报
List集合的特点
            有序  有索引  元素可重复
  ArrayList implements List
  
  public boolean add(E e):向集合末尾处,添加指定的元素
  public void  add(int index, E e):向集合指定索引处,添加指定的元素,原有元素依次后移
  public boolean remove(E e):将指定元素对象,从集合中删除,返回值为被删除的元素
  public E remove(int index):将指定索引处的元素,从集合中删除,返回值为被删除的元素
  public E set(int index, E e):将指定索引处的元素,替换成指定的元素,返回值为替换前的元素
  public E get(int index):获取指定索引处的元素,并返回该元素
  
  List接口有两个实现类
   ArrayList
   LinkedList
java.util.ArrayList
     实现类List  
       特点   
           有序  有索引  可重复
           底层数据是数组 查询快 增删慢
           线程不安全 效率高
  
boolean contains(Object o) 判断集合是否包含某个元素
  判断两个元素是否相等的依据为 对象equals方法
  java.util.Vector
      实现List
       特点
           有序 有索引  可重复
           底层数据是数组 查询快 增删慢
            线程安全 效率低
java.util.LinkedList
     实现了List接口
       特点
           有序  有索引 元素可重复
           底层数据是链表 查询慢 增删快
           线程不安全  效率高
  
public void addFirst(E e)将指定元素插入此列表的开头。
  public void addLast(E e)将指定元素添加到此列表的结尾
  public E getFirst()返回此列表的第一个元素
  public E getLast()返回此列表的最后一个元素。
  public E removeFirst()移除并返回此列表的第一个元素
  public E removeLast()移除并返回此列表的最后一个元素
java.util.HashSetimplements Set
      特点
            无序   唯一
            底层数据是哈希表  查询和增删都比较快
  
  hashCode()equals()方法
    先比较hashCode方法
        如果hashCode不同 添加到集合
        如果hashCode相同 继续比较equals
                      如果 相同  不添加了
                     如果  不同  添加到集合
java.util.Set  extends Collection
      特点
            元素唯一
  HashSet 无序唯一
  LinkedHashSet 有序唯一
java.util.LinkedHashSet implementsSet
       特点
           有序 唯一
                 底层数据是链表 + 哈希表
            链表来保证有序  哈希表保证唯一 都是使用hashCodeequals方法保证元素唯一
java.util.HashSet存储自定义类型
保证元素唯一性  需要自定义类型重写hashCodeequals方法  alt+shift+s+ h
  
  hashCode()equals()方法
    先比较hashCode方法
        如果hashCode不同 添加到集合
        如果hashCode相同 继续比较equals
                      如果 相同  不添加了
                     如果  不同  添加到集合

回复 使用道具 举报
java.util.Map<K,V> 接口
   Map集合是双列集合的顶层接口
   K:Map集合的键 键是唯一的
   V:Map集合的值  值可以重复
   
   常用方法
       V  put(K key ,V value) 向集合中添加元素 一般返回的是一个null 当键重复时,新值会覆盖掉旧值,返回值返回的是 旧值
       V  get(Object key); 根据key返回值
       Vremove(Object key)根据 key删除键值对元素
   
   两个实现类
   HashMap
       无序  键唯一
   LinkedHashMap
       有序  键唯一
Map集合的遍历
   
   Map集合的第一种遍历方式 根据键找值
     Set<K> keySet()返回一个包含所有键的Set集合
     
   1.创建集合对象 添加数据
   2.调用Map集合keySet方法,获取所有键的Set集合
   3.遍历Set集合,依次获取每个key,调用Map集合get(Object key)获取所有的值
Map集合第二种遍历方式
   方法
    Set<Map.Entry<K,V>>   entrySet() 返回键值对关系对象(结婚证)的 Set集合
   Map.Entry
       getKey
       getvalue
   
   1.创建Map对象 添加数据
   2.调用entrySet方法 返回所有结婚证(键值对关系对象 Enry对象)Set集合
   3.遍历Set集合 一次获取每个结婚证(Entry对象)
   4.根据结婚证(Entry对象) 找到 (key) 找到妻(value
Map存储自定义类型 自定义类型作为Map的键
   
   先比较hashCode
       如果hashCode不同 添加到集合
       如果hashCode相同 比较equlas
                相同 不添加
                不同 添加
   
   Map集合存储自定义类型 保证键的唯一 需要自定义类型 重写hashCodeequals方法
  java.util.LinkedHashMap extendsHashMap
          特点  
             有序  键唯一
JDK1.5 新特性  可变参数
   前提
        方法的参数的数据类型确定 参数的个数不确定
   格式
       数据类型...变量名  可变参数的本质就是数组
   可变参数的注意事项
       1.一个方法只能有一个可变参数
       2.一个方法如果有多个参数时,可变参数要放到最后
java.util.Collections 集合的工具类
   static void shuffle(List list) 打乱集合顺序 只能传入List集合
   static void sort(List list)  为集合排序 默认为自然排序 12 3  a b c

回复 使用道具 举报
java.io.File 文件  目录  路径的抽象表现形式
   文件:File 存储数据
   目录:Directory 文件夹  存储文件 区分文件
   路径:Path  路径  定位文件或文件夹
   特点 :平台无关性
   File的静态常量
       staticString pathSeparator 与系统有关的路径分隔符
         windows下是 “;”  unix下是 “:”
       staticString separator  与系统有关的默认名称分隔符
           Windows下是 “\”  Unix下是 “/”
   Uri 统一资源标识符
       包括url
       thrunder:sssss
       ed2k:
       mailto:123@qq.com
   Url 统一资源定位符
       http:\\www.baidu.com
File类构造方法
   new File(“e:\\project\\a.txt”);
  new File(“e\\project”,”a.txt”)
  new File(new File(“e:\\project”),”a.txt”); == new File(dir,”a.txt”)
   绝对路径
       从盘符开始的路径都是绝对路径
       d:\\work\\abc  唯一性
   相对路径
       d:\\work\\abc
       d:\\work
       d:\\work\\day04
   
       父路径是唯一的 ,但是子路径是无限的
java.io.File
   File的创建方法
   
   不可以通过一个文件的文件名是否有后缀 来区分文件和文件夹
   windows操作系统不区分大小写
   文件夹和文件即使类型不同 也不可以重名
boolean exists()
         判断构造方法中的路径是否存在
         返回boolean类型  存在为true 不存在为false
boolean isDirectory() 判断是否是文件夹
boolean isFile() 判断是否是文件
          返回boolean类型   如果返回true则是文件
          但是如果返回false可能是文件夹 也可能构造方法中路径不存在
          使用时,需要先判断 路径是否存在,判断后,除了文件就是文件夹
File的删除方法
    boolean delete() 删除文件或文件夹 返回boolean类型删除成功为true删除失败为false
             删除的是文件 ,如果文件中有数据 也可以删除
             删除的是文件夹,如果文件夹中有文件或者嵌套了文件夹,是删除不了的
          注意:java中的删除叫做永久性删除 不走回收站
              运行有风险,操作需谨慎
  File    getAbsoluteFile() 推荐
String  getAbsolutePath()
         获取绝对路径的方法,但是返回值类型不同
Filelist开头的方法
   String[] list() 返回当前文件夹下 所有的文件的文件名的数组   包括
隐藏文件
   String[] strs = file.list();
   File[] listFiles() 返回当前文件夹下所有文件对象
   File[] files = file.listFiles();
   static File[] listRoots()  返回当前系统的盘符
eg:
遍历文件夹及子文件夹下的所有文件 递归方法
File file = new File(“E:\\project”);
Public static void getAll(File file){
File[] files =file.listFiles();
For(File f : files){
    If(f.isDirectory()){
       getAll(f);
    }else{
        Syso(f);
    }
}
}
Eg2:
遍历给出文件夹及子文件夹下后缀为.java的文件  使用递归和过滤类
File file = new File(“E:\\project”);
Public static void getAll(File file){
File[] files =file.listFiles(new MyFileFileFilter());
For(File f : files){
    If(f.isDirectory()){
       getAll(f);
    }else{
        Syso(f);
    }
}
}
Class MyFileFilter implements FileFilter{
       @override
       Public Booleanaccept(File pathname){
              Booleanb1 = false;
              Booleanb2 = false;
          If(pathname.isFile()){
                     B1= pathname.getName().endsWith(“.java”);
              }
       If(pathname.isDirectory){
                     B2= true;
              }
Return b1 || b2 ;
}

回复 使用道具 举报
回复 使用道具 举报
回复 使用道具 举报
加油,楼主一起共勉哈
回复 使用道具 举报
{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}{:8_492:}
回复 使用道具 举报
做成思维导图就跟方便了!
回复 使用道具 举报
java.io.OutputStreamWriter extends Writer字符流转换成字节流的桥梁
   特点可以指定编码表 可以使用父类的write方法  写一个字符  一个字符数组 字符数组一部分  及字符串
   
   构造方法
        OutputStreamWriter(OutputStream out)
        OutputStreamWriter(OutputStreamout, String charsetName)
        参数
            OutputStream out 需要的是字节输出流的超类 ,可以传入其任意子类
                             FileOutputStream
            String charsetName 指定的编码表 不写默认是GBK  可以指定编码表
                                   编码表  不区分大小写 不要乱写
java.io.InputStreamReader extends Reader 字节通往字符的桥梁
   特点 可以指定编码  可以使用父类的read方法 读一个字符 读一个字符数组
   
   构造方法
        
        InputStreamReader(InputStream in)
        InputStreamReader(InputStreamin,String charsetName)
        参数
            InputStreamin 需要的是字节输入流的超类,可以传入其任意子类
                           FileInputStream
            StringcharsetName 指定的编码表 不写默认是GBK  可以指定编码表
                                   编码表  不区分大小写 不要乱写  
===================================================================================
java.io.ObjectOutputStream 序列化流  将对象写入硬盘的文件
   构造方法
        ObjectOutputStream(OutputStream out)
        参数
            OutputStream out 需要的是字节输出流的超类 ,可以传入其任意子类对象
                             FileOutputStream
        方法
            voidwriteObject(Object obj)  写对象
   java.io.ObjectInputStream 反序列化流  读取文件中的对象
   构造方法
        ObjectInputStream(InputStream in)
        参数
            InputStream in 需要的是字节输入流的超类,可以传入其任意子类对象
                           FileInputStream
        方法
            ObjectreadObject() 读对象
标记型接口   实现Serializable接口允许序列化和反序列化
   静态内容不能序列化 因为我们是对象的序列化 ,而静态内容不属于对象
   transient:瞬态关键字 作用唯一 不让该字段序列化
==================================================================================
打印流
   字节打印流PrintStream
   字符打印流PrintWriter
   打印流的特点
        1.打印流只负责输出目的
        2.打印流永远不抛IO异常 可能抛其他异常
        3.它为其他流添加了功能
   PrintStream 构造方法可以接收 字符串File对象 所有字节输出流
   PrintWriter 构造方法可以接收 字符串  File对象 所有字符输出流 所有字节输出流
   
   打印流可以开启自动刷行
        前提
            1.构造方法接收的必须是流对象
                PrintWriter(OutputStream out,boolean autoFlush)
                PrintWriter(Writer out, booleanautoFlush)
                参数
                    boolean autoFlush 如果为true则开启自动刷行 如果为false则不开启
            2.只有3个方法可以开启自动刷行  printf println format
===============================================================================
java.util.Properties
   特点
    1 Hashtable的子类,map集合中的方法都可以用。
    2该集合没有泛型。键值都是字符串。
    3. 可以直接和IO流结合使用
  
   添加元素的方法
      setProperty(String key, String value) 添加元素
     String getProperty(String key) 根据键获取值
     Set<String> stringPropertyNames() 获取所有键的集合
PropertiesIO流结合使用
   
    voidload(InputStream inStream)  将文件中的键值对直接读入到集合
    voidload(Reader reader)
    参数
     只要是输入流即可
   
   
   
     voidstore(OutputStream out, String comments) 将集合中的键值对写入到配置文件
     voidstore(Writer writer, String comments)
     参数
         只要输出流就可以
          String comments 修改配置文件的解释
   org.apache.commons.io.FileUtils
    staticString readFileToString(Filefile)
    staticvoid   writeStringToFile(File file,String data)
    staticvoid  copyFile(File srcFile, FiledestFile)  复制文件
static void  copyDirectoryToDirectory(File srcDir, FiledestDir)  复制文件夹 可以复制多级
PrintWriter pw= new PrintWriter(newFileWriter("e:\\project\\a.txt",true),true);
第一个true表示字符流的追加写 第二个true表示自动刷新
PrintWriter pw2 = new PrintWriter(newFileOutputStream("e:\\project\\a.txt",true));
第一个true表示字节流的追加写


回复 使用道具 举报
总结:

        final String file = "e:\\project\\a.txt";
//      字节流
        InputStream in = new FileInputStream(file);
        OutputStream out = new FileOutputStream(file,true);
//      缓冲字节流
        BufferedInputStream bis =new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file,true));
//      字符流
        FileReader fr =new FileReader(file);
        FileWriter fw = new FileWriter(file,true);
//      缓冲字符流
        BufferedReader br = new BufferedReader(new FileReader(file));
        BufferedWriter bw = new BufferedWriter(new FileWriter(file,true));
//      转换流可设置编码格式字节转字符InputStreamReader   字符转字节OutputStreamWriter
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");
        OutputStreamWriter isw = new OutputStreamWriter(new FileOutputStream(file,true),"GBK");

        BufferedReader br2 = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
        BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file,true)));
//      打印字符流打印字节流PrintStream 省略
        PrintWriter pw = new PrintWriter(new FileOutputStream(file,true),true);
        PrintWriter pw2 = new PrintWriter(new FileWriter(file,true),true);
//      Properties 简况
        Properties p = new Properties();

        p.setProperty("age", "18");//类似于 map.put(k,v);
        p.getProperty("age");      //       map.get(key)
        p.stringPropertyNames();    //      map.keySet();

        p.load(in);
        p.load(bis);

        p.store(out, "");
        p.store(bos, "");

        Map<Integer,String> map = new HashMap<Integer,String>();

        map.put(1, "Lily");
        map.put(2, "Lucy");
        map.put(1, "Tom");
        map.put(1, "Jim");

        Set<Integer> keys = map.keySet();
        for(Integer num : keys){
            String thisValue = map.get(num);
        }

        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for(Map.Entry<Integer, String> entry : entrySet){
            entry.getKey();
            entry.getValue();
        }


回复 使用道具 举报
java.lang.Thread 线程类
   
   开启线程步骤 (第一种方式 继承Thread)
   1.定义一个类 继承Thread
   2.重写Thread类的run方法(线程任务)
   3.创建子类对象
   4.调用start方法
   
    String getName() 返回线程名
    void setName(String name) 设置线程名
    static Thread currentThread() 返回当前线程对象的引用
   
   startrun方法区别
   如果调用的run方法 程序还是一个单线程的程序
   只有调用start方法 JVM会启用开启的线程 自动调用run方法
         Threadt = new Thread(){
            @Override
            public void run() {
                System.out.println("!!!");
            }
        };
        t.start();
线程创建的第二种方式 (实现Runnable)
   
   1.定义一个类实现Runnable接口
   2.重写run方法
   3.创建Thread对象 ,在构造方法中传入Runnable实现类对象
               Thread(Runnabletarget)
   4.调用start方法开启线程
         Runnabler = new Runnable() {
            @Override
            public void run() {
                System.out.println("###");
            }
        };
        Threadt2 = new Thread(r);
        t2.start();
匿名内部类创建线程
   
   作用:创建一个类/接口  子类/实现类对象的快捷方式
   new 父类/接口(){
      重写方法
   };
         new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("bb");   
            }
        }).start();
Thread类的sleep方法
   static void sleep(longmillis)  休眠几毫秒

回复 使用道具 举报
解决线程的安全隐患的方式采取同步的方式
   同步代码块
      synchronized(任意对象){
               可能会出现问题的代码块
      }
         public void run() {
        while(true){
            synchronized (this) {
                if(i>0){
                    try {
                        Thread.sleep(10);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
                    i--;
                }
               
            }
            
        }
    }
   同步方法
         public static synchronized void sell(){
//      synchronized(SubThread.class) {
            if(i>0){
                try {
                    Thread.sleep(10);
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
                i--;
            }
//      }
    }
解决线程的安全隐患的方式 采取同步的方式
   同步代码块
      synchronized(任意对象){
               可能会出现问题的代码块
      }
   同步方法
     在方法的声明上加入关键字synchronized
     同步方法有锁吗? 锁是谁? this
     同步方法可以是静态的吗 可以  静态的同步方法锁还是this吗? 绝对不是
    那是谁? 类名.class
     
    效率和安全
    线程 安全 效率低
    线程不安全 效率高
JDK1.5
   使用Lock接口来解决线程安全问题
   
   java.util.concurrent.locks.Lock 接口
   实现类ReentrantLock
                void lock() 获取锁
                void unlock() 释放锁
int i = 100; //100张票
    Lock l = new ReentrantLock();
    @Override
    public void run() {
        while(true){
                l.lock();
                if(i>0){
                    try {
                        Thread.sleep(10);
                        System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
                        i--;
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        l.unlock();
                    }   
                }
            }
    }

回复 使用道具 举报
java.net.InetAddress IP地址
   静态方法(创建对象)
               static InetAddress getLocalHost() 返回本地主机
               static InetAddress getByName(Stringhost) 返回指定主机的IP对象  IP地址  主机名 网址
  
   方法
                String getHostName() 返回当前IP下的主机名
                String getHostAddress() 返回当前IP下的字符串IP
InetAddress address = InetAddress.getLocalHost();//tom-PC/192.168.107.56
       StringhostName = address.getHostName(); //tom-PC
       StringhostAddress = address.getHostAddress();//192.168.107.56
      
       InetAddress address2 = InetAddress.getByName("tom-pc");//tom-PC/192.168.107.56
       InetAddress address3 = InetAddress.getByName("127.0.0.1");///127.0.0.1
       InetAddress address4 = InetAddress.getByName("www.baidu.com");//www.baidu.com/119.75.218.70
UDP协议发送端
     发送端套接字  java.net.DatagramSocket
               构造方法
                                 DatagramSocket()  创建发送端对象
               方法
                                  void send(DatagramPacket p) 发送数据包
     发送端的数据包 java.net.DatagramPacket
               构造方法
                                 DatagramPacket(byte[]buf, int length, InetAddress address, int port)
length不能超过字节数组的长度  一般设置为buff.length
                                 创建数据包对象 封装数据  接收端地址 及端口号
   1.创建发送端对象DatagramSocket
   2.准备数据
   3.创建数据包的对象封装 封装数据  接收端地址 及端口号
   4.调用DatagramSocketsend方法发送数据包DatagramPacket
   5.关闭资源
        DatagramSocket ds = new DatagramSocket();
        
        byte[] buf = "你好".getBytes();
        DatagramPacketdp = new DatagramPacket(buf,buf.length, InetAddress.getLocalHost(), 6666);
        
        ds.send(dp);
        ds.close();
UDP的接收端
      接收端套接字  java.net.DatagramSocket
               构造方法
                          DatagramSocket(int port)创建接收端对象
               方法
                          void receive(DatagramPacket p) 接收数据包
       接收端数据包java.net.DatagramPacket
               构造方法
                        DatagramPacket(byte[] buf,int length) 接收长度为length的数据包
   1.创建接收端对象
   2.创建DatagramPacket接收端数据包的对象
   3.调用DatagramSocketreceive接收数据包
   4.拆包
               DatagramPacket
                         int getLength() 获取长度
                         int getPort() 获取端口
                        InetAddress getAddress() 获取ip
   5.关闭资源
DatagramSocket ds= newDatagramSocket(6666);
        //接收数据包最大为64k
        byte[] buf = new byte[1024*64];
        DatagramPacketdp = new DatagramPacket(buf, buf.length);
        ds.receive(dp);
        InetAddressaddress= dp.getAddress();
        //获取接收数据的真实长度
        int len = dp.getLength();
        buf = dp.getData();
        System.out.println(new String(buf,0,len));
        
        ds.close();

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马