Java学习第六周小结

day18--day22

1.Character类 1.1概念

Charaacter:Character类是基本数据类型char类型的包装类类型,包含char的值;此外，该类还提供了

几种方法来确定字符的类别（小写字母，数字等），并将字符从大写转换为小写，反之亦然。

1.2构造方法

Character(char value) :参数里面也可以为int :将一个字符内容构造成包装类类型

1.3成员方法

<1>public static boolean isDigit(char ch):判断当前ch字符是否为数字

<2>public static boolean isLowerCase(char ch):判断当前ch字符是否为小写字母字符

<3>public static boolean isUpperCase(char ch)确定指定的字符是否为大写字符。

2.Date类 2.1概念

java.util.Date:表示日期格式:精确到瞬间毫秒.

2.2构造方法

<1>public Date():无参构造方法,获取当前系统时间的日期格式,默认使用当前系统时间.

<2>public Date(long date):将long类型-构造成Date对象:long指定时间毫秒值(与1970年1月1日).

2.3成员方法

public long getTime():将Date日期格式----转换成long类型返回自1970年1月1日以来的Date毫秒数

2.4String日期文本格式和Date格式之间的转换

public final String format(Date date): 将日期格式化成日期/时间字符串

public SimpleDateFormat(String pattern):参数为描述日期和时间格式的一种模式

public Date parse(String source) 解析方法,可能出现解析异常,当前字符串开头不能解析就出问题.

(1)Date-----String

<1>创建日期对象

<2>创建SimpleDateFormat对象:中间桥梁,格式化/解析工具

<3>利用public final String format(Date date)完成转换

Date date = new Date() ;//1
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;//2
String dateStr = sdf.format(date);//3

(2)String-----Date

<1>创建String文本

注意:当前的SimpleDateFormat的模式必须和字符串文本格式对应!,否则解析出问题

<2>创建SimpleDateFormat对象

<3>利用public Date parse(String source)解析完成

String sourc = "2008-5-12" ;//1
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd" ) ;//2
Date date2 = sdf2.parse(sourc);//3

3.Calendar类 3.1概念

java.util.Calendar:为抽象类;表示的是特定一组时间:诸如YEAR,MONTH,DAY_OF_MonTH 等等.

3.2成员变量

Calendar成员变量为常量;

<1>public static final int YEAR :年

<2>public static final int MONTH:月:角标是从0开始计算, 计算出来+1

<3>public static final int DATE:月中的日期和DAY_OF_MONTH同义词

其余查看API获取时分秒

3.2Calendar实例化

Calendar calendar = new Calendar();构建具有默认时区和默认的FORMAT语言环境的日历.

如果一个类定义为抽象类,那么目的是不让这个类实例化,它肯定会有静态功能,返回值它本身.

public static Calendar getInstance(): 使用默认时区和区域设置获取日历;Calendar返回的

是基于默认时区的当前时间.

3.3成员方法

<1>public int get(int field):获取当前的日历字段

<2>public abstract void add(int field,int amount):设置时间偏移量,针对当前日历字段,减去或者添加

指定amount(偏移量).

<3>public final void set(int year,int month,int date):设置日历字段中的值YEAR;MONTH;DAY_OF_MONTH

月份从0开始.

Calendar calendar = Calendar.getInstance();//创建日历对象
int year = calendar.get(Calendar.YEAR) ;//获取当前日历字段
int month = calendar.get(Calendar.MONTH) ;
int date = calendar.get(Calendar.DATE) ;
calendar.add(Calendar.YEAR,5) ;//设置偏移量
year = calendar.get(calendar.YEAR) ;

4.System类 4.1概念

System类:不能实例化;里面提供一些标准输入流.

4.2静态字段---常量

<1>public static final InputSteam in ;字节输入流

<2>public static final PrintStream out ;字节输出流

4.3静态功能

<1>public static void gc():手动开启垃圾回收器

<2>public static void exit(int status):参数为0,正常终止JVM

<3>public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)复制数组

<4>public static long currentTimeMillis():计算当前系统时间毫秒值

5.Math类 5.1概念

java.lang.Math: 数学的运算工具类;都是静态的功能.

5.2常用功能

<1>public static double abs(double/int a):求绝对值

<2>public static double ceil(double a):向上取整

<3>public static double floor(double a):向下取整

<4>public static double max(double a,double b):获取最大值

<5>public static double min(double a,double b):获取最小值

<6>public static double random():(0,1) :获取0,1之间随机数

<7>public static long round(double a):四舍五入

<8>public static double sqrt(double a):开正方根

<9>public static double pow(double a,double b):a的b次幂

注意:jdk5以后新特性:静态导入,可变参数,自动拆装箱,增强for循环,枚举

import java.util.Scanner ; //类级别

import static java.lang.Math.abs ;//方法级别

6.Random类 6.1概念

java.util.Random:伪随机数生成器

6.2构造方法

<1>Random():创建随机数生成器,通过它调用功能获取的随机数是不同的.

<2>Random(long seed):创建随机数生成器,通过它调用功能,产生随机数值相同的

6.3成员方法

<1>public int nextInt():获取随机数int类型范围

<2>public int nextInt(int n):获取0-n之间随机数,不包括n

7.BigDecimal类 7.1概念

java.math.BigDecimal:对小数进行精确计算.

7.2构造方法

<1>public BigDecimal(String val) :将数字字符串构造成BigDecimal对象

<2>public BigDecimal(int val):将int转换为BigDecimal

7.3常用方法

<1>public BigDecimal add(BigDecimal augend)求和

<2>public BigDecimal subtract(BigDecimal subtrahend)相减

<3>public BigDecimal multiply(BigDecimal multiplicand):乘

<4>public BigDecimal divide(BigDecimal divisor)除

<5>除的时候,还可以保留小数的精确位数

public BigDecimal divide(BigDecimal divisor,int scale, RoundingMode roundingMode)

参数1:指定的除数;参数2:保留的有效位数;参数3:指定舍入模式: ROUND_HALF_UP 四舍五入

8.选择排序 8.1选择排序思想

思想:使用0角标对应的元素依次和后面角标对应的元素进行比较,小的往前放,第一次比较完毕最小

值出现在最小索引处,依次比较,比较的次数:数组长度-1次.

8.2代码实现

for(int i = 0;i < arr.length-1;i++){
            for(int j = i + 1;j < arr.length;j++){
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
}

9.Collection集合 9.1集合的概念

集合: 一种容器,能够存储引用数据类型的容器,长度可变.

9.2Collection基本功能

<1>boolean add(Object e)：添加任意类型

<2>boolean remove(Object o)：删除指定的元素

<3>void clear()：暴力删除,将集合中所有元素删除

<4>boolean contains(Object o)：判断集合中是否包含指定的元素

<5>boolean isEmpty():判断是否为空,不为空,false;空,true

<6>int size():获取集合的元素数

9.3集合和数组的区别

(1)长度的区别

数组长度:固定集合长度:可变

(2)存储数据类型区别

数组:既可以存储基本数据类型,而且存储引用数据类型

集合:只能存储引用数据类型

(3)存储元素区别

数组:既可以存储基本数据类型,而且可以存储引用数据类型,元素类型必须统一

集合:虽然只能存储引用数据类型,但是没有泛型<>情况下可以存储任何引用类型, 模拟数组的特点.

9.4集合高级功能

<1>boolean addAll(Collection c):添加一个集合中的所有元素

<2>boolean containsAll(Collection c):包含一个集合的所有元素:包含所有算包含

<3>boolean removeAll(Collection c):删除一个集合中包含另一个集合中的某个元素,就算删除,返回

true

<4>boolean retainAll(Collection c):将交集的元素保存A集合中,boolean表达的意思:将保存在A集合

中的元素是否和之前的元素发生变化,如果前后发生变化,则返回true;没有变化,则返回false.

9.5泛型

(1)泛型就是集合对象在创建同时明确数据类型,并且将运行时期异常提前到编译时期(模拟数组定

义).使用<引用数据类型>

(2)泛型的好处:

<1>提高程序安全性

<2>解决黄色警告线

<3>使用集合的迭代器避免强制类型转换

Collection c = new ArrayList<>() ;
后面的<>可以写上,也可以不写;jdk7以后泛型推断:默认的认为前后类型一致

(3)JDK5以后,提供了泛型,提高程序安全性,将运行时期异常,提前编译时期,

(4)泛型的定义方式

<1>泛型定义在类上

public class ObjectTool {}
ObjectTool ot = new ObjectTool<>() ;
ot.show("hello") ;
ObjectTool ot2 = new ObjectTool<>() ;
ot2.show(100) ;

<2>将泛型定义在方法上

public  void show(T t){}
泛型定义在方法上的格式:权限修饰符  返回值类型 方法名(T 参数名){}

<3>将泛型定义在接口上

1)接口的子实现类已经明确了类型

明确了泛型,集合添加只能当前类型,直接添加不了其他类型,后期通过反射

public interface Inter {
    void show(T t) ;
}
情况1:接口的子实现类已经明确了类型
public class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("show InterImpl...");
    }
}

Inter inter = new InterImpl<>() ;
inter.show();

2)接口的子实现类不明确里面存储的类型

情况2:子实现类不明确泛型的类型
public class InterImpl implements Inter{
    @Override
    public void show(T t) {
        System.out.println(t) ;
    }
}

Inter inter = new InterImpl<>() ;
inter.show(100) ;
Inter inter2 = new InterImpl<>() ;
inter2.show("helloworld") ;

(5)泛型的通配符

<1>:代表Object或者任意的Java类型(jdk提供/自定义的)

<2>:向下限定,E这个类型以及它的子类

<3> :向上限定,E这个类以及它的父类

10.迭代器 10.1概念

迭代器是集合专有的遍历方式;迭代器是接口,是通过ArrayList的内部类来实现他里面的hasNext()和next().

10.2面试题:为什么将迭代器不定义为一个类,而是接口?

如果是类,使用继承的特点,子类继承父类,可以继承父类非私有的成员,继承具有局限性,不仅获取到

了需要的,其他不需要的也获取过来了;提供接口,面向接口编程,提高功能扩展,谁实现了接口,就具备

当前这个额外功能.

10.3迭代器的使用

Iterator iterator():迭代器:集合专有遍历方式

Iterator:接口<1>boolean hasNext() 判断是否有下一个可以迭代的元素 (判断功能)

<2>Object next():获取下一个可以迭代的元素(获取功能)

Collection c = new ArrayList() ;
c.add("hello") ;
c.add("world") ;
c.add("java") ;
Iterator it = c.iterator();
 while(it.hasNext()){
    String s = (String) it.next();
    System.out.println(s+"---"+s.length());
}

注意:next()使用的时候,不能使用多次,否则造成数据丢失.

11.List集合 11.1List集合的特点

有序:存储和取出一致;元素可以重复.

11.2List集合特有功能

<1>void add(int index, Object element):在指定位置处添加一个新的元素

<2>Object remove(int index):删除指定位置处的元素

<3>E set(int index, Object element):修改指定位置处的元素内容

<4>Object get(int index):获取指定位置处的元素

<5>ListIterator listIterator():列表迭代器

ListIterator接口:

boolean hasNext() :判断当前列表中是否有下一个可以遍历的元素

Object next():获取下一个元素

boolean hasPrevious():判断当前列表中是否有上一个可以遍历的元素

Object previous():获取上一个元素

注意:前提条件:必须有正向遍历,才能使用反写遍历;

11.3List集合5种遍历方式

方式1:Collection集合的toArray()----Object[]
List list = new ArrayList<>();
    list.add("hello");
    list.add("world");
    list.add("javaee");
    Object[] objects = list.toArray();
    for(int i = 0;i < objects.length;i++){
        String s = (String)objects[i];
        System.out.println(s+"---"+s.length());
    }

方式2:Coillection集合的Iterator迭代器
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    String next = iterator.next();
    System.out.println(next);
}

方式3:get(int index) + size() 的普通for循环
for(int i = 0;i < list.size();i++){
    String s = list.get(i);
    System.out.println(s);
}

方法4:使用列表迭代器
ListIterator stringListIterator = list.listIterator();
while(stringListIterator.hasNext()){
    String next = stringListIterator.next();
    System.out.println(next);
}

方法5:增强for循环
for(泛型数据类型 变量名 : 集合对象名称){
    输出变量名;
}

for(String s:list){
    System.out.println(s);
}

11.4典型例题

(1)使用List存储字符串数据,遍历这个list集合,如果当前元素内容有"world",需要给List中添加一个新

的元素"php".

java.util.ConcurrentModificationException 并发修改异常

解决方案:<1>使用集合判断,使用集合添加或者修改

<2>使用迭代器,使用迭代器添加/修改

for(int x = 0 ; x < list.size() ; x ++){
    String s = list.get(x) ;
            判断
        if("world".equals(s)){
                集合添加
            list.add("php");
        }
}
System.out.println(list);

使用ListIterator列表迭代器中添加功能void add(E e)
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
            获取
    String s = listIterator.next();
    if("world".equals(s)){
                迭代器添加
        listIterator.add("php"); 在指定元素后面插入
    }
}

(2)使用List存储多个字符串,有重复元素,如何去重

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

方式2:选择排序思想
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);
}

12.List集合

ArrayList:底层数据结构是数组,数组的特点:查询快,增删慢.从线程角度考虑:由于实现是不同步的,执

行效率高,线程不安全.默认容量为10个,以1.5倍扩容.

Vector:底层数据结构是数组,查询快,增删慢.线程角度:实现同步的,里面的成员方法大部分都会有

synchronized同步锁,保证安全性安全性很高,但是执行效率低,单线程程序中,使用ArrayList替代

Vector.

linkedList:底层数据结构是一个链表,线程角度:不同步的,单线程中执行效率高,安全性低!链表:数据

域和指针域组成.

12.1ArrayList

(1)构造方法:

<1>public ArrayList():构造一个初始容量为十的空列表

<2>public ArrayList(int initialCapacity):指定容量大小

(2)ArrayList嵌套for使用

ArrayList> bigArray = new ArrayList<>() ;
for(ArrayList array :bigArray){
    for(Student s :array ){
        System.out.println(s.getName()+"t"+s.getAge());
    }
}

12.2Vector

(1)Vector集合:在List集合中最明显的特点:线程安全

(2)特有功能

<1>public void addElement(Object obj):添加元素

<2>public boolean removeElement(Object obj):直接从Vector集合中删除指定的元素

<3>public Object elementAt(int index):通过指定的索引值获取元素

<4>public Enumeration

Java学习第六周小结

Java相关栏目本月热门文章