Java 入门 6

1. int 和 String 之间如何转换

1) int---->String

方式1:空串拼接

int x = 100;
String result = ""+x;

方式2:利用中间桥梁:包装类类型Integer

//Integer(int i) + 成员方法String to String()
int i = 100;
Integer x = new Integer(i);
String result = x.toString();

方式3:public static String toString(int i){}

int i = 100;
String result = Integer.toHexString(i);

2) String----->int

方式1:通过Integer的构造方法 Integer(String s ) + public int intValue()

String s = "5";
Integer i = new Integer(s);
int result = i.intValue;

方法2: Integer 类的静态功能:直接转换

//public static int parseInt(String s)throws NumberFormatException
//其他的String -----> 转 基本类型:都是通用的方法
int result = Integer.parseInt(s);

2. Character

2.1 概念

Character类是基本数据类型char类型的包装类类型,包含char的值.此外，该类还提供了几种方法来

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

2.2 构造方法

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

2.3 成员方法

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

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

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

//键盘录入字符串,包含数字,大写字母,小写字母字符(不考虑特殊字符),统计出现的个数
import java.util.Scanner;
public class CharacterTest {
    public static void main(String[] args) {

        //定义统计变量
        int bigCount = 0 ;
        int smallCount = 0 ;
        int numberCount = 0 ;

        //创建键盘录入对象
        Scanner sc  = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个字符串: ") ;
        String line = sc.nextLine() ;

        //方式1:---字符数组  方式2:----自己for循环变量
        for(int i = 0 ; i < line.length() ; i++){
            char ch = line.charAt(i) ;

            //使用Character静态功能判断
            if(Character.isDigit(ch)){
                numberCount ++  ;
            }else if(Character.isLowerCase(ch)){
                smallCount ++ ;
            }else if(Character.isUpperCase(ch)){
                bigCount ++ ;
            }
        }
        System.out.println("数字字符共有"+numberCount+"个") ;
        System.out.println("大写字母字符共有"+bigCount+"个") ;
        System.out.println("小写字母字符共有"+smallCount+"个") ;
    }
}

3. Date

3.1 概念

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

3.2 构造方法

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

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

3.3 成员方法

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

3.4 String和Date格式之间转换

# 开发中:前后端交互:前端提交的日期数据是String类型,但是数据库中存储的时间是Date格式

DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间。但是它是一个抽象类.抽象类不能实例化,它提供了更具体的子类SimpleDateFormat进行操作!

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

yyyy:表示年    2009
MM:月           07/11
dd:月中的天     01

HH:小时数      14 (24小时制)
mm:分钟数      02
ss:秒数 03

4. Calendar

4.1概念

Java.util.Calendar:抽象类, 表示的特定一组时间:诸如YEAR,MONTH,DAY_OF_MONTH 等等

4.2 成员变量--常量

1) public static final int YEAR :年

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

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

时分秒:查看API

4.3 静态功能

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

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

4.4 成员方法

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开始.

/*
 * 键盘录入任意年份,计算出2月份有多少天? (不考虑特殊年)
 *
 * 分析:
 *      1)键盘录入一个年份,int类型的值
 *      2)创建日历类对象Calendar,getInstance()
 *      3)设置日历字段的 值set(year,2,1) ; ----2---->3月(month需要加1)
 *      4)只要给月中日期Date设置偏移量add(Calendar.Date,-1) ; //2月的最后一天
 *      5)获取日历中的Date这个字段
 *      6)输出即可
 *
 */
import java.util.Calendar;
import java.util.Scanner;
public class CalendarTest {
    public static void main(String[] args) {

        Scanner sc  = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入任意的年份值: ") ;
        int year = sc.nextInt() ;

        //创建日历对象
        Calendar c = Calendar.getInstance();

        //设置当前的日历字段
        c.set(year,2,1); //此时应该是3月1号

        //设置Date字段的偏移量
        c.add(Calendar.DATE,-1) ;

        System.out.println("任意年份的2月份有:"+c.get(Calendar.DATE));
    }
}

5. System类

5.1概念

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

5.2 静态字段(常量)

1) public static final InputSteam in ;

2) public static final PrintStream out ;

5.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.4 final,finalize()的区别

前者关键字,后者方法

1) final:状态修饰符 / 修饰类,不能被继承 / 修饰方法,不能重写 / 修饰变量,是一个常量

2) finalize(),当垃圾回收器开启的时候,会调用子类的finalize()方法,来回收没有更多引用的对象!

一般情况:不需要手动开启回收器,自动回收!

(Jvm:本质: 至少两条线程:main线程(用户线程),垃圾回收线程...)

6. Random类

6.1概念

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. Math类

7.1概念

java.lang.Math: 数学的运算工具类

7.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随机数,不包含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 ;//方法级别 jdk5以后新特性:静态导入

import static 包名.类名.静态方法名;

8. BigDecimal类

8.1概念

Java提供这样一个类 BigDecimal:对小数进行精确计算的

8.2 构造方法

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

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

8.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 四舍五入

9. 选择排序

选择排序思想:

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

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

核心代码:

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 ;
                }
            }
        }

10. 集合

10.1 概念

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

10.2 集合和数组的区别

1) 长度的区别
数组长度:固定
集合长度:可变
2) 存储数据类型的区别
数组:既可以存储基本数据类型,而且存储引用数据类型
int[] arr = new int[5] ;
Student[] students= new Student[3] ;
集合:只能存储引用数据类型
3) 存储元素的区别:
数组:虽然以存储基本数据类型,而且存储引用数据类型,元素类型必须统一
String[] strArray = {"hello","world","JavaEE",100} ;不行,报错
集合:虽然只能存储引用数据类型,但是可以存储任何引用类型, 没有泛型<>:模拟数组的特点

10.3 Collection集合

某些集合允许重复元素(List)，而其他集合不允许(Set)。有些有序和有序无序。

JDK不提供此接口的任何直接实现,提供了更具体的子接口---->子实现类间接实现!

集合的有序性:存储和取出一致！ / 无序：存储和取出不一致！

10.4 Collection的基本功能

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():获取集合的元素数

10.5 集合高级功能

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

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

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

true (将交集的元素保存A集合中,boolean表达的意思:将保存在A集合中的元素是否和之前的元素发生变化如果前后发生变化,则返回true;没有变化,则返回false)

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

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

10.6 泛型

泛型的写法: <引用数据类型>

泛型作用:就是将集合的对象的创建工作,将运行时期异常,提前到编译时期,解决程序安全性!

创建集合对象: 集合<数据类型> 对象名 = new 子实现类<>() ;jdk7泛型推断

集合的传统遍历: Object[] toArray():将集合转换对象数组

10.6.1 泛型的好处

<1>提高程序安全性

<2>解决黄色警告线

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

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

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

10.6.2 泛型的定义方式

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) 将泛型定义在接口上

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();

3.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") ;

10.6.3泛型的通配符

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

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

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

11.迭代器

11.1概念

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

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

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

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

当前这个额外功能.

11.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.4 增强for循环

dk5以后提供了特性:增强for循环

作用:替代迭代器的Iterator,简化书写方式

格式:
for(泛型数据类型变量名 : 集合对象名称){ //增强for循环遍历数组非常少,主要用在集合中
输出变量名;
}

前提条件:集合对象不能为null,否则就出现空指针异常

12. List集合

12.1 概念

List是Collection的子接口,有Collection大部分功能,他是它自己有功能

12.2 List集合特点

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

12.3 List接口特有功能:

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():列表迭代器

12.3.4 ListIterator listIterator():列表迭代器

ListIterator接口:

ArrayList内部类ListItr,(父类:ArrayList的内部类Itr)实现它里面的方法

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

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

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

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

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

12.4 List集合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);
}

12.5 例题

(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);
}

13.List集合子实现类

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

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

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

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

Vector.

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

域和指针域组成.

13.1 ArrayList

(1) 构造方法:

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

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());
    }
}

13.2 Vector

(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