Java编程 Javase09

于 2021-03-24 20:58:29 发布
阅读量223 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kkh01421/article/details/114898414
版权

一、包装类

（一）概念

1、定义：将基本类型的数据包装起来，这个类叫包装类。在包装类中可以定义一些方法，用来操作基本类型的数据。

2、基本数据类型除int——Integer，char——Character外其余均为首字母大写

（二）装箱与拆箱

  • 装箱：从基本类型转换为对应的包装类对象。
  • 拆箱：从包装类对象转换为对应的基本类型。

1、装箱

构造方法：

Integer（int value）：构造一个新分配的Interger对象，它表示指定的int值

Integer（String s）：构造一个新分配的Interger对象，它表示String参数所指示的int值。

  • 传递的字符串必须是基本类型的字符串，否则会抛出异常

静态方法：

static Interger valueOf（int i）返回一个表示指定的int值的Interger实例。

static Interger valueOf（String s）返回保存指定的String的值的Interger对象。

2、拆箱

成员方法：int intvalue（）：以int类型返回Interger的值。

public static void main(String[] args) {
        //装箱
        Integer in1=new Integer(1);
        System.out.println(in1);
        Integer in2=new Integer("1");
        System.out.println(in2);
        Integer in3=Integer.valueOf(1);
        System.out.println(in3);
        Integer in4=Integer.valueOf("1");
        System.out.println(in4);
        //拆箱
        int i=in1.intValue();
        System.out.println("i");

    }
1
1
1
1
i

（三）自动装箱与自动拆箱

  • 基本数据类型和包装类之间可以自动地相互转换
public static void main(String[] args) {
        //Jdk1.5版本后出现的特性
        Integer in1=190;//自动装箱
        in1=in1+1;//先自动拆箱为整数数据，加1后自动装箱
        System.out.println(in1);
        //集合中的自动装箱与拆箱
        ArrayList<Integer> list=new ArrayList<>();
        //ArrayList接收的为包装类，在接受数据时发生自动装箱
        list.add(890);
        System.out.println(list.get(0));//包装类转换为整数后输出，发生了自动拆箱

    }
191
890

（四）基本类型与字符串之间的转换

1、基本类型转换为字符串

  • “+”连接
  • 包装类中的静态方法：static String toString（int i）返回一个表示指定整数的String对象
  • String类中的静态方法：static String valueOf（int i）返回int参数的字符串形式

2、字符串转换为对应的基本类型

  • 除了Character类之外，其他所有包装类都具有parseXxx方法将字符串参数转换为对应的基本类型

例如：public static int parseInt(String s):将字符串参数转换为对应的int基本类型

  

 public static void main(String[] args) {
       //基本数据类型——》字符串
        int num=100;
        System.out.println(num+"200");//100200
        String s1=Integer.toString(100);
        System.out.println(s1+200);//100200
        String s2=String.valueOf(100);
        System.out.println(s2+200);//100200
        //字符串——》基本数据类型
        int i= Integer.parseInt("100");
        System.out.println(i+"love");//100love
    }

二、Collection集合

（一）集合概述

1、定义：集合是java中提供的一种容器，可以用来存储多个数据

2、集合与数组的区别

  • 数组的长度是固定的，集合的长度是可变的
  • 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象，而且对象的类型可以不一样，在开发中当对象较多的时候，使用集合进行存储。

（二）集合框架

  • Vector、ArrayLIst、LinkedLIst、TreeSet、HashSe、LinkedeHashSet集合

1、List集合

  • 有序的集合（存储和取出元素顺序相同）
  • 允许存储重复的元素
  • 有索引，可以使用普通的for循环遍历。
  • Vector、ArrayLIst、LinkedLIst集合

2、Set接口

  • 不允许存储重复元素
  • 没有索引（不能使用普通的for循环遍历）

3、Collection接口

  • 定义的是所有单列集合中共性的方法
  • 所有单列集合都可以使用共性的方法
  • 没有带索引的方法

4、集合框架的学习方式

  • 学习顶层：学习顶层接口/抽象类中共性的方法，所有的子类都可以使用
  • 使用底层：底层不是接口就是抽象类，无法创建对象使用，需要使用底层的子类创建对象使用。

（三）Collection集合

  • 单列集合最顶层的接口

 1、collection集合常用的方法

boolean add（E e）； 向集合中添加元素
boolean remove（E e）； 删除集合中的某个元素
void clear（）；        清空集合所有的元素
boolean contains（）； 判断集合中是否包含某个元素
boolean isEmpty（）； 判断集合是否为空
int size（）；         获取集合的长度
Object[ ] toArray（）； 将集合转成一个数组
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("Love");
        coll.add("is");
        coll.add("shit");
        System.out.println(coll);
        coll.remove("shit");
        System.out.println(coll);
        coll.contains("people");
        coll.contains("love");
        System.out.println(coll.isEmpty());
        int length= coll.size();
        System.out.println(length);
        Object[] str=coll.toArray();
        for (int i = 0; i < length; i++) {
            System.out.println(str[i]);
        }
        coll.clear();
        System.out.println(coll);
    }
[Love, is, shit]
[Love, is]
false
2
Love
is
[]

2、collection集合的常用功能

  • collection是所有单列集合的最顶层的接口，里边定义了所有单列集合共性的方法。任意的单列集合都可以使用collection接口中的方法。
  • 共性方法
public boolean add（E e）； 向集合中添加元素
public boolean remove（E e）； 删除集合中的某个元素
public void clear（）；        清空集合所有的元素
public boolean contains（）； 判断集合中是否包含某个元素
public boolean isEmpty（）； 判断集合是否为空
public int size（）；         获取集合的长度
public Object[ ] toArray（）；把集合当中的元素存储到数组当中

三、Iterator迭代器

  • 迭代：即collection集合元素的通用获取方式。再取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来。一直把集合中所有的元素全部取出来。这种取出的方式叫做迭代。
  • Iterator迭代器是一个接口，无法直接使用。需要使用Iterator接口的实现类对象，获取实现类的方法比较特殊。
  • Collection接口有一个方法叫iterator，该方法返回的就是迭代器的实现类对象。
  • Iterator<E> iterator() 返回在此 collecton的元素上进行迭代的迭代器。

 

1、常用方法

boolean hasNext（）

  • 如果仍有元素可以迭代，则返回true。判断集合中还有没有下一个元素，有就返回true，没有则返回false。

E next（）

  • 返回迭代的下一个元素并取出集合中的下一个元素。

2、迭代器的使用步骤

  • 使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口实现（多态)
  • 使用Iterator接口中的方法hasNext判断还有没有下一个元素
  • 使用Iterator接口中的方法next取出集合中的下一个元素
  • Iterator<E>接口也是有泛型的，迭代器的泛型跟集合走，集合是什么泛型，迭代器就是什么泛型。（多态 接口       实现类对象）
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo04 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangmazi");
        coll.add("wuqi");
        coll.add("zhaoliu");
        Iterator<String> str = coll.iterator();
        //使用while循环遍历
        while(str.hasNext()){
            String s= str.next();
            System.out.println(s);
        }
        for (int i = 0; i < 20; i++) {
            System.out.print("=");
        }
        System.out.print("\n");
        //使用for循环遍历
        for(Iterator<String> str2 = coll.iterator(); str2.hasNext();){
            String s2= str2.next();
            System.out.println(s2);
        }
    }
}
zhangsan
lisi
wangmazi
wuqi
zhaoliu
====================
zhangsan
lisi
wangmazi
wuqi
zhaoliu

3、迭代器的实现原理

4、增强for

  • 增强for循环（for each循环）是专门用来遍历数组和集合的，它们的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
for（元素的数据类型 变量名 ；Collection集合或者数组）{
    //操作代码
}
它用于遍历Collecton和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。
public static void main(String[] args) {
        //使用增强for循环遍历数组
        int[] arr = new int[] {1, 2, 3, 4, 5 };
        for (int i:
             arr) {
            System.out.println(i);
        }
        ArrayList<String> list =new ArrayList();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangmazi");
        for(String s: list){
            System.out.println(s);
        }


1
2
3
4
5
zhangsan
lisi
wangmazi

四、泛型

（一）泛型的概念

  • 泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。
  • 泛型也可以视作一个变量，用来接收数据类型。E e：Elemen 元素 T t：Type类型

 

（二）使用泛型的好处

1、不使用泛型

  • 好处：集合不使用泛型，默认的就是Object类型，可以存储任意类型的数据
  • 弊端：不安全，会引发异常

2、使用泛型

  • 好处：避免了类型转换的麻烦，存储到是什么类型，取出的就是什么类型。把运行期异常（代码运行之后会抛出异常），提升到了编译器（写代码时会报错）
  • 弊端：泛型是什么类型，只能存储什么类型的数据。
public static void main(String[] args) {
        //show1();
        show2();
    }

    private static void show2() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1)  不能添加int类型
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }

    /*private static void show1() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            System.out.println(obj);
            //会发生类型转换异常，不能把整数类型转换为字符串类型
            String s = (String)obj;
            System.out.println(s.length());

        }


    }*/
//输出为
  abc->3

（三）定义和使用含有泛型的类

1、定义格式

修饰符 class 类名<代表泛型的变量> { }
  • 泛型的数据类型在创建对象的时候确定

2、代码实现

public class Ge<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }

    public Ge() {
        this.name = name;
    }
}


public static void main(String[] args) {
        Ge gc1 =new Ge();
        gc1.setName("任意的");
        Object obj =gc1.getName();
        System.out.println(obj);

        Ge<Integer> gc2 =new Ge<>();
        gc2.setName(123);
        Integer n = gc2.getName();
        System.out.println(n);

        Ge<String> gc3=new Ge<>();
        gc3.setName("love");
        String s =gc3.getName();
        System.out.println(s);

    }
/*任意的
123
love*/

（四）定义和使用含有泛型的方法

1、定义格式

修饰符<代表泛型的变量> 返回值类型 方法名（参数列表（使用泛型））{ }

 2、使用格式：调用方法时确定泛型的类型

  • 含有泛型的方法，在调用方法的时候确定泛型的数据类型
  • 传递什么类型的参数，泛型就是什么类型

 

public class GM {
    public <M> void method1(M m){
        System.out.println(m);
    }
    //创建一个静态方法
    public static <G> void method2(G g){
        System.out.println(g);
    }
}


  public static void main(String[] args) {
        GM gm =new GM();
        gm.method1("abc");
        gm.method1(123);
        gm.method1(0.2135);
        gm.method1(true);
        //使用静态方法时 类名.方法名（参数）
        GM.method2("abc");
        GM.method2(123);
    }
/*abc
123
0.2135
true
abc
123*/

（五）定义和使用含有泛型的的接口

1、定义格式

修饰符 interface接口名<代表泛型的变量> { }

2、使用格式

  • 第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型
  • 第二种使用方式 ：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走。就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型。

（六）泛型的通配符

1、通配符的基本使用

  • 通配符：不不知道使用什么类型来接收的时候，此时可以使用？来表示，？表示未知通配符。此时只能接收数据，不能往该集合中存储数据。
  • 使用方式：不能创建对象使用，只能作为方法的参数使用 
  • 注意：泛型没有继承概念
public class p {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(123);
        list.add("zhangsan");
        list.add(0.125);

        putarray(list);
    }


    public static void putarray(ArrayList<?> list){
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object o =it.next();
            System.out.println(o);
        }
    }
}

/*输出为：
123
zhangsan
0.125*/

2、通配符的高级使用—受限泛型

  • Java中可以指定一个泛型的上限和下限

泛型的上限

  • 格式 ：类型名称 <? extends 类> 对象名称
  • 意义：只能接收该类型及其子类

泛型的下限

  • 格式：类型名称<? super类> 对象名称
  • 意义：只能接受该类型及其父类型 

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值