java学习笔记6(上)

最新推荐文章于 2024-09-14 18:46:05 发布

离一

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量96

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_48989708/article/details/120955216

版权

1.String和StringBuffer之间如何转换:

//String---->StringBuffer
//方式1:StringBuffer的有参构造方法
public StringBuffer(String str)
//方式2:StringBuffer的无参构造方法+append(追加){}
public StringBuffer()
public StringBuffer append(String str)   
    
//StringBuffer----->String
  //方式1:String类的有参构造方法
public String(StringBuffer buffer)
//方式2:StringBuffer的功能:toString
public String toString()

2.int和String之间进行互相转换?

//int--->String
int i = 100 ;
String s = "" ;
String reuslt = s +i ; //"100"
//Integer(int i) 
Integer ii = new Integer(i) ;
//成员方法public String toString() 
String result2 = ii.toString() ;
//方式3:Integer的静态功能public static String toString(int i)

//String---->int
//String---long
//String----double
//Integer的paseInt()

3.Character类

是基本的数据类型char类型的包装类类型,包含char的值.
构造方法:Character(char value)参数里面也可以为int--char:将一个字符内容构造成包装类类型.
成员方法:  判断功能:
 public static boolean isDigit(char ch):判断当前ch字符是否为数字
 public static boolean isLowerCase(char ch):判断当前ch字符是否为小写字母字符
 public static boolean isUpperCase(char ch)确定指定的字符是否为大写字符

4.date类

表示 日期格式:精确到瞬秒.
构造方法: public Date():无参构造方法,获取当前系统时间的日期格式  默认使用当前系统时间
public Date(long date):将long类型-构造成Date对象:long指定时间毫秒值(与1970年1月1日)
成员方法:
public long getTime():将Date日期格式---转换成long类型返回自1970年1月1日以来的Date毫秒数.
注意:咋开发中:前后端交互:前端提交的日期数据----String类型.
数据库中储存的的时间:Date格式:
    String日期文本格式如何和Date格式之间相互转换:
    DateFormat是日期/时间格式化子类的抽象类,它以语言无关的方式格式化和分析日期或时间.是一个抽象类.抽象类不能实例化,他提供了更具体的子类SimpleDateFormat进行操作.
    java.util.Date对象---SimpleDateFormat-----
    String日期文本格式.
    格式化格式:
    public final Stringformat(Date date)
     yyyy:表示年    2009
     MM:月           07/11
     dd:月中的天     01
     HH:小时数      14  (24小时制)
     mm:分钟数      02
     ss:描述        03
     构造方法:publicSimpleDateFormat(String patten):参数为描述日期和时间格式的一种模式;
     将String--------SimpleDateFormat------Date 解析

5.Calendar抽象类

表示的特定一组时间:诸如YEAR,MONTH,DAY-OF_MONTH等
如何实例化:
  如果一个类定义为抽象类,那么目的是不让这个类实例化.
   它肯定会有静态功能,返回值它本省.
静态功能:
   public static Calendar getInstance()
成员变量---常量
   public static final int YEAR :年
   public static final int MONTH:月:角标是从0开始计算, 计算出来+1 public        static final int DATE:月中的日期 和DAY_OF_MONTH同义词
成员方法:
   public int get(intfield):获取当前的日历字段你
   public abstract voidadd(int field,intamount):设置时间偏移量,针对当前日历字段,减去或者添加指定amount.
   举例:键盘录入一个年份,判断这个年份的二月份有多少天?

   package com.jhq5.test1.work02;

import java.util.Calendar;
import java.util.Scanner;

public class CalendarTest {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //提示录入月查询的年份的2月;
        System.out.println("请输入你要查询的年份的2月:");
        int year=sc.nextInt();
        //创建日历对象
        Calendar c = Calendar.getInstance();
        //设置当前日历对象
        c.set(year,2,1);
        //设置偏移量
        c.add(c.DATE,-1);
        System.out.println(year+"年的2月份有"+c.get(Calendar.DATE)+"天");
    }
}

2.当前日历为2021-2-1,计算5年后的10天前?

package com.jhq5.test1.work3;

import java.util.Calendar;

public class CalendarTest {
    public static void main(String[] args) {
        //创建日历对象;
        Calendar c = Calendar.getInstance();
        //获取当前系统的日期;
        c.set(2021,01,01) ;
        //5年前
        c.add(Calendar.YEAR,5);
       int year = c.get(Calendar.YEAR);
        int month=c.get(Calendar.MONTH);
        //10天前
        c.add(Calendar.DATE,-10);
       int day=c.get(Calendar.DATE);
        System.out.println("5年后的10天前是"+year+"年"+month+"月"+day+" 日");
    }
}

6.System类

不能实例化,里面提供一些标准的输入流,
静态字段(常量)
 public static final  InputSteam in ;
 public static final  PrintStream out ;
静态功能:
 public static void gc() //手动开启垃圾回收器
 public static void exit(int status)//:参数为0,正常终止JVM
 public static void arraycopy(Object src,int srcPos,Object dest,int          destPos, int length)//复制数组
 public static long currentTimeMillis()//:计算当前系统时间毫秒值
System的gc()方法的作用:
  调用gc()方法,其实质调用Object类的finalize()方法,需要被子类覆盖,将没有更多引用的对象进行垃圾回收,以释放
当前所占用的内存空间!

7.面试题:

final,finalize()的区别:
   前者关键字,后者方法.
   final,状态修饰符,修饰类,不能被继承;修饰方法,不能重写;修饰变量,是一个常量.
   finalize(),当垃圾回收器开启的时候,会调用子类的finalize()方法,来回收没有更多引用      的对象.
    一般情况:不需要手动开启回收器,自动回收.

8.Random类

是伪随机数生成器
构造方法:
  Random():创建随机数生成器,通过它调用功能获取的随机是不同的   (使用无参构造居多)
  Random(long seed):创建随机数生成器,通过它调用功能,产生随机数值相同的
 成员方法:
      public int nextInt():获取随机数int类型范围
      public int nextInt(int n):获取0-n之间随机数,不包括n  (重点)

9.Math类

数学的运算工具类;(功能都是静态)
 public static double abs(double/int a):求绝对值
 public static double ceil(double a):向上取整
 public static double floor(double a):向下取整
 public static double max(double a,double b):获取最大值
 public static double min(double a,double b):获取最小值
 public static double random():[0,1) :获取0,1随机数,不包含1
 public static long round(double a):四舍五入
 public static double sqrt(double a):开正方根
 public static double pow(double a,double b):a的b次幂

10.BigDecimal类

对小数进行精确计算的
  public BigDecimal(String val) :将数字字符构造成BigDecimal对象
 功能
    public BigDecimal add(BigDecimal augend)求和
    public BigDecimal subtract(BigDecimal subtrahend)相减
    public BigDecimal multiply(BigDecimal multiplicand):乘
    public BigDecimal divide(BigDecimal divisor)除
除的时候,还可以保留小数的精确位数
    public BigDecimal divide(BigDecimal divisor,int scale, RoundingMode    roundingMode)
   参数1:指定的除数
   参数2:保留的有效位数
   参数3:指定舍入模式: ROUND_HALF_UP 四舍五入

11.选择排序

思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前放,第一次比较完毕,最小值出现在最小索引处,依次比较,比较的次数:数组长度-1;
代码:

public class ArrayDemo {

    public static void main(String[] args) {
        //给定一个数组
        int[] arr = {24,68,87,57,13} ;

        System.out.println("排序前:");
        //自己的功能
        printArray(arr) ;
         System.out.println("排序后:");
         selectSort(arr);
          printArray(arr) ;
     private static void selectSort(int[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {//比较次数
            for (int y = x + 1; y < arr.length; y++) {//遍历后面的元素
                //判断
                if (arr[y] < arr[x]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }

    public static void printArray(int[] arr){
        System.out.print("[") ;
        for(int x = 0 ; x < arr.length ; x++){
            if(x == arr.length-1){
                System.out.println(arr[x] +"]") ;
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}

12.String和StringBuffer的区别:

StringBuffer:可变的字符序列,线程安全的类
    StringBuffer:字符串缓冲区中存储的字符序列,最终使用的时候---->String
    1)String(StringBuffer buffer)
    2)String toString() ;
String:不支持可变,特点:常量,一旦被赋值,其值不能被更改
    StringBuffer(String str)
    StringBuffer()+append(String str)

13.集合和数组的区别:

长度的区别:
    集合:长度是可变的
    数组:长度是固定的
存储数据类型的区别:
    集合:只能存储引用数据类型
    数组:既可以存储基本数据类型,也可以存储引用数据类型
存储元素的区别:
    集合:可以存储任何引用类型的元素,没有泛型
    数组:存储的这些类型(基本/引用),同一种类型的元素

14.集合去遍历字符串数据,toArray()方式的操作步骤:

//创建集合对象
Collection c = new ArrayList() ;
//给集合中添加字符串数据
c.add("hello") ;
c.add("world") ;
c.add("JavaEE") ;
c.add("Android") ;
//将集合转换成对象数组Object[]
Object[] objs = c.toArray() ;//相当于每一个Object obj = new String() ;
//遍历对象数组
for(int x = 0 ; x < objs.length; x ++){
    //直接输出objs[x] 
    //获取字符串数据的同时,获取字符串长度 length()
    String s = (String)objs[x] ;
    System.out.println(s +"---"+s.length()) ;
}

15.Collection集合的高级功能

  boolean addAll(Collection c):添加一个集合中的所有元素
  boolean containsAll(Collection c):包含一个集合的所有元素 (思考:包含一个算包含,还是所有元素)
  boolean removeAll(Collection c):删除一个算删除还是删除所有算删除?    结论:删除一个集合中包含另一个集合中的某个元素,就算删除,返回true.
  面试题:
  boolean retainAll(Collection c): 求集合中的交集元素,boolean的表达式意思是什么?
   A集合对B集合求交集,boolean 什么情况true/什么情况下false
   将交集的元素保存A集合中,boolean表达的意思:将保存在A集合中的元素是否和之前的元素发生变化
   如果前后发生变化,则返回true;没有变化,则返回false!

16.Iterator:接口

Iterator<E> iterator():迭代器:集合专有遍历方式
 Iterator:接口
 boolean hasNext() 判断是否有下一个可以迭代的元素 (判断功能)
 Object next():获取下一个可以迭代的元素          (获取功能)

17.增强for循环:

 作用:替代迭代器的Iterator,简化书写方式
  格式:   
  for(泛型数据类型 变量名 : 集合对象名称){  //增强for循环 遍历数组非常少,主要用在集合中
           输出变量名;
       }
     前提条件:集合对象不能为null,否则就出现空指针异常
     目的:替代迭代器!

18.List 集合

是Collection的子接口,有Collection大部分功能,也有自己的功能.
特点:
  有序:存储和取出一致;
  元素可以重复;
特有的功能:
  void add(int index, Object element):在指定位置处添加一个新的元素
  Object remove(int index):删除指定位置处的元素
  E set(int index, Object element):修改指定位置处的元素内容
  Object get(int index):获取指定位置处的元素
  ListIterator<E> listIterator():列表迭代器
  举例:
     使用List存储多个字符串,有重复的元素,如何去重!
     (1)新建集合思想:

 public class ListTest2 {

    public static void main(String[] args) {

        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;
        //创建一个新的集合
        List<String> newList = new ArrayList<>() ;
        //遍历旧集合获取每一个元素:增强for
        for(String s:list){
            //在新集合中判断是否包含这个元素,如果不包含,才给新集合中添加
            if(!newList.contains(s)){
                newList.add(s) ;
            }
        }
        //遍历新集合
        for(String s:newList){
            System.out.println(s);
        }
    }

}

     (2)利用选择排序思想:

  public class ListTest3 {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<>() ;

        list.add("hello") ;
        list.add("world") ;
        list.add("javaee") ;
        list.add("hello") ;
        list.add("world") ;
        list.add("world") ;
        list.add("hello") ;
        list.add("javaee") ;
        list.add("android") ;
        list.add("android") ;
        list.add("php") ;
        list.add("php") ;
        //选择排序的核心代码
        for(int x = 0 ; x < list.size()-1; x++){
            for(int y = x+1 ; y < list.size() ; y ++){
                //业务思想:如果前面的元素和后面元素一致,将后面的重复元素删除掉
                if(list.get(y).equals(list.get(x))){
                    //将后面的元素删除
                    list.remove(y) ;
                    y -- ;
                }
            }
        }
        //遍历当前这个集合
        for(String s :list){
            System.out.println(s);
        }
    }
}

19.ListIterator接口

 ListIterator<E> listIterator():列表迭代器
  ListIterator接口:
           ArrayList内部类ListItr,(父类:ArrayList的内部类Itr)实现它里面的方法
           boolean hasNext() :判断当前列表中是否下一个可以遍历的元素
           Object next():获取下一个元素
           boolean hasPrevious():判断当前列表中是否有时上一个可以遍历的元素
           Object previous():获取上一个元素
           前提条件:必须有正向遍历,才能使用反写遍历;

20.泛型

 1.1泛型的好处:
           1)提高程序安全性
           2)解决警告线
           3)使用集合的迭代器避免强转类型强转类型转换
 1.2将泛型定义在接口上
     1)接口的子实现类已经明确了类型
     2)接口的子实现类不明确里面存储的类型
 1.3 泛型定义在方法上的格式:权限修饰符 <T> 返回值类型 方法名(T 参数名){...}
  固定格式  T--->Type 任何类型 
 1.4  public class ObjectTool<T> {泛型定义在类上
 1.5泛型的通配符(了解)
  <?>:代表Object或者任意的Java类型(jdk提供/自定义的)
  <? extends E>:向下限定,E这个类型以及 它的子类
  <? super E> :向上限定 E这个类以及它的父类