Java基础-4（System类的两个常用方法，StringBuilder类，包装类及拆装箱，Collection集合）

24.System类的两个常用方法

java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:

• public static long currentT imeMillis():返回以毫秒为单位的当前时间。

• public static void arraycopy(object src, int srcPos, object dest, int destPos, int length) :将数组中指定的数据拷贝到另一一个数组中。

public class Demoe1System {
	public static void main(String[] args) {
		//demo01();
        //demo02();
	}
	/*
	public static long currentTimeMillis(): 返回以毫秒为单位的当前时间。
	用来测试程，序的效率
	练习:
	验证for循环打印数字1 - 999所需要使用的时间(毫秒)
	*/
	private static void demo01() {
        //程序执行前,获取一次毫秒值
		long s = System. currentTimeMillis();
		//执行for循环
		for(inti=1;i<=9999;i++){
		System.out.print1n(i);
		//程序执行后,在获取一次毫秒值
		long e = System. currentTimeMillis();
		System.out.println( "程序共耗时:"+(e-s)+"毫秒");
		}
    }
    /*
	public static void arraycopy(object src, int srcPos, object dest, int destPos, int length):
	将数组中指定 的数据拷贝到另-一个数组中。
	参数:
	src -源数组。
	srcPos -源数组中的起始位置。
	dest-目标数组。
	destPos -目标数据中的起始位置。
	length -要复制的数组元素的数量。
	*/
	private static void demo02() {
		//定义源数组
		int[] src = {1,2,3,4,5};
		//定义目标数组
		int[] dest = {6,7,8,9,10};
		System.out.print1n(“复制前:"+ Arrays . toString(dest));
        //使用System类的方法arraycopy将src数组中前3个元素，复制到dest数组的前3个位置上
		System.arraycopy(src, srcPos: e,dest, destPos: 0, length: 3);
		System.out.print1n("复制后:"+ Arrays.toString(dest));
}

25.StringBuilder

String类
1.字符串是常量;它们的值在创建之后不能更改。
2.字符串的底层是一个被final修饰的数组,不能改变,是一个常量
private final byte[] value;—>底层的定义

例如：

String s= "a"+"b"+"c";
原来已有 "a"，"b"，"c"三个字符串
此时先 s="a"+"b"="ab"，一个新的字符串
再s="ab"+"c"="abc"，又是一个新字符串
总共5个字符串，占据了较多的空间

StringBuilder类
字符串缓冲区，可以提高字符串的操作效率(看成-个长度可以变化的字符串)
底层也是一个数组,但是没有被final修饰,可以改变长度
byte[] value = new byte[16];–>注意这里没有final关键字可以修改

例如：定义一个容量为15的StringBuilder数组，则"a"+“b”+"c"原理如下图，一个一个字符添加进数组空间，避免了申请新的空间

• 构造方法

/*
java. lang. StringBuilder类:字符串缓冲区,可以提高字符串的效率
构造方法:
- public StringBuilder():构造一个空的StringBuilder容器。
- public StringBuilder(String str): 构造一个StringBuilder容器， 并将字符串添加进去。
*/
public class Demo01StringBuilder {
	public static void main(String[] args) {
		StringBuilder bu1 = new StringBuilder();
		System.out.print1n("bu1:"+bu1);//bu1:
		StringBuilder bu2 = new StringBuilder("abc");
		System.out.print1n("bu2 :"+bu2);//bu2:abc
    }
}

• 常用方法

StringBuilder常用的方法有2个:
●public StringBuilder appnd(...) :添加任意类型数据的字符串形式,并返回当前对象自身。
●public String tostring() :将当前StringBuilder对象转换为String对象。

1. append方法：append方法具有多种重载形式,可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如:

/*
	StringBuilder类的成员方法:
	public StringBuilder append(...): 添加任意类型数据的字符串形式，并返回当前对象自身。
	参数:
	可以是任意的数据类型
*/
public class Demo02StringBuilder {
	public static void main(String[] args) {
		//创建StringBui lder对象
		StringBuilder bu1 = new StringBuilder();
      /*
		//使用append方法往StringBuilder中添加数据
        //append方法返回的是this ,调用方法的对象bu1
		StringBuilder bu2 = bu1.append(" abc");
		System.out.println(bu1);//abc
		System.out.println(bu2);//abc
		System.out.print1n(bu1==bu2);//true两个对象是同一个对象
	  */
      /*
        //使用append方法无需接收返回值
		bu1.append("abc" );
		bu1.append(1);
		bu1.append(true);
		bu1.append(8.8);
		bu1.append('中');
		System.out.println(bu1);
	  */
        
        /*
        链式編程:方法的返回值是一个对象,可以根据对象继续调用方法
        */
        bu1.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu1);
	}
}

2.toString方法

StringBuilder和String可以相互转换:

1).String->StringBuilder:可以使用StringBuilder的构造方法
2).StringBuilder(String str) 构造一个字符串生成器,并初始化为指定的字符串内容。
3)StringBuilder->String :可以使用StringBuilder中的tostring方法
4)public String toString(): 将当前StringBuilder对象转换为String对象。

public class Demoe3StringBuilder {
	public static void main(String[] args) {
		//String- >StringBuilder
		String str = "hello";
		System.out.print1n("str:"+str);
		StringBuilder bu = new StringBuilder(str);
        
		//往StringBuilder中添加数据
		bu.append( "world");
		System. out. print1n("bu:"+bu);
        
		//StringBuq der->String .
		String s = bu.toString();
		System.out.println("s:"+s);
	}
}

• System和StringBuilder小结
  • System类
    • 1.currentTimeMillis()方法–>作用:获取当前系统毫秒值时间
    • 2.arraycopy()方法–>作用:复制数组
• StringBuilder类
  • 1.构造方法
    • StringBuilder();创建一个空的字符串缓冲区对象
    • StringBuilder(String s);根据传入的内容创建一个字符串缓冲区对象
  • 2.成员方法
    • StringBuilder append(Object obj);添加内容
    • StringBuilder reverse();反转内容
    • String toString();将缓冲区内容转为字符串

26.包装类

• 概念：基本数据类型的数据，使用起来非常的方便但是没有对应的方法来操作这些数据，所以我们可以使用一个类，把基本类型的数据包装起来这个类叫包装类。在包装类中可以定义一些方法用来操作基本类型的数据。

java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:

基本类型	对应包装类（位于Java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
booleam	Boolean

• 装箱与拆箱

基本类型与对应的包装类对象之间,来回转换的过程称为”装箱”与"拆箱”:
装箱:从基本类型转换为对应的包装类对象。
拆箱:从包装类对象转换为对应的基本类型。
用Integer与int为例: (看懂代码即可)
基本数值—>包装对象

Integer i = new Integer(4);//使用构造 函数函数
Integer iii= Integer.value0f(4);//使用包装类中的value0f方法

包装对象—>基本数值

int num = i. intValue();

具体例子：

/*
	装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
	构造方法:
		Integer(int value) 构造-一个新分配的Integer 对象，它表示指定的int值。
		Integer(String s)构造一-个新分配的Integer 对象，它表示String 参数所指示的int值。
		传递的字符串,必须是基本类型的字符串,否则会抛出异常”100” 正确"a"抛异常
	静态方法:
		static Integer value0f(int i) 返回一个表示指定的int 值的Integer 实例。
		static Integer valueOf(String s)返回保存指定的String的值的Integer 对象。
	拆箱:在包装类中取出基本类型的数据(包装类- >基本类型的数据)
	成员方法:
	int intValue() 以int类型返回该Integer 的值。
*/
public class Demo01Integer {
	public static void main(String[] args) {
		//装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
		//构造方法
		Integer in1 = new Integer( value: 1);//方法 上有横线,说明方法过时了
		System.out.println(in1);//1重写了tostring方法
		Integer in2 = new Integer( S: "1");
		System.out.println(in2);//1
        
		//静态方法
		Integer in3 = Integer . value0f(1);
		System.out.println(in3);
		Integer in4 = Integer . value0f("1");
		System.out.println(in4);
        
        //拆箱:在包装类中取出基本类型的数据(包装类- >基本类型的数据)
		int i = in1.intValue();
		System.out.println(i);
	}
}

• 自动拆箱和自动装箱

由于我们经常要做基本类型与包装类之间的转换,从ava5 (JDK1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:

Integer i = 4;//自动装箱。相当于Integer i = Integer .value0f(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i. intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

具体例子

public Class Demo02Integer {
	public static void main(String[] args) {
		/*
		自动装箱:直接把int类型的整数数赋值给包装类
		Integer in = 1;就相当于Integer in = new Integer(1);
		*/
		Integer in = 1;
		/*
		自动拆箱: in是包装类,无法直接参与运算,可以自动转换为基本类型的数据,再参与计算
		in + 2;就相当于in.intValue() + 2 = 3;
		in + 2;就相当于in = new Integer(3) 自动装箱
		*/
		in=in+2;
        
        //Arraylist集合无法直接存储整数,可以存储Integer包装类
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);//自动装箱list. add(new Integer(1));
		int a = list.get(0);// 自动拆箱list. get(0). intValue();
}

• 基本类型和字符串类型的相互转换

基本类型转换String总共有三种方式,最简单的一种方式:
基本类型直接与""相连接即可;如: 34+""
String转换成对应的基本类型
除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:

1. public static byte parseByte(String s) :将字符串参数转换为对应的byte基本类型
2. public static short parseShort(String s) :将字符串参数转换为对应的short基本类型
3. public static int parseInt(String s) :将字符串参数转换为对应的int基本类型。
4. public static long parseLong(String s) :将字符串参数转换为对应的long基本类型。
5. public static float parseFloat(String s) :将字符串参数转换为对应的float基本类型。
6. public static double parseDouble(String s) :将字符串参数转换为对应的double基本类型。
7. public static boolean parseBoolean(string s) :将字符串参数转换为对应的boolean基本类型。
   代码使用(仅以Integer类的静态方法parseXxx为例)如:

public class Demo18WrapperParse {
	public static void main(String[] args) {
		int num = Integer.parseInt("100");
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java. lang.NumberFormatException异常。

具体例子：

/*
	基本类型与字符串之间的转换
	基本类型-->字符串
        1.基本类型数据的值+””最简单的方式(工作中常用)
        2.使用包装类中的静态方法
        	static String tostring(int i)返回- -个表示指定整数的String 对象。
        3.使用String类中的静态方法
        	static String valueOf(int i) 返回int参数的字符串表示形式。
    字符串-->基本类型
        使用包装类的静态方法parseXX(”字符串")
            Integer类: static int parseInt(String s)
            Double类:static double parseDouble(String s)
    		...
*/
public class Demoe3Integer {
	public_ static void main(String[] args) {
		//基本类型-->字符串
		String s1 = 100+"" ;
		System.out.println(s1+200);//100200
	
        String s2 = Integer.toString( i: 100);
        System.out.println(s2+200);//100200

        String s3 = String . value0f(100);
        System.out.println(s3+200);//100200
        
        //字符串-- >基本类型
        int i = Integer.parseInt( S: "100");
        System.out.print1n(1+200);//300

        int i2 = Integer.parseInt( S: "a");//NumberFormatException: For input string: "a" 数字格式化异常
        System.out.println(i2);

	}
}

• 总结

1.基本数据类型对应的包装类，具体看上面内容中的表格

2.数字转换为字符串，有三种方式，最简单的方式就是直接加入“”

3.字符串转为数字，用包装类中对应的静态方法进行转换

4.自动装拆箱

27.Collection集合

• 概述

集合:集合是java中提供的一种容器,可以用来存储多个数据。

集合和数组既然都是容器，它们有啥区别呢?

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

• 框架

集合按照其存储结构可以分为两大类,分别是单列集合java.util.collection和双列集合java.util.Map )

Collection :单列集合类的根接口,用于存储一 系列符合某种规则的元素,它有两个重要的子接口,分别是java.util.List和java.util.Set.其中, List的特点是元素有序、元素可重复。Set 的特点是元素无序,而且不可重复。List 接口的主要实现类有 java. util.ArrayList 和 java. util. LinkedList，Set 接口的主要实现类有java.util.HashSet和java. util. TreeSet。

集合本身是一个工具,它存放在java.util包中。在Collection接口定义着单列集合框架中最最共性的内容。

• 常用功能

Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set通用的一些方法,这些方法可用于操作所有的单列集合。方法如下:

1. public boolean add(E e) :把给定的对象添加到当前集合中 。
2. public void clear() :清空集合中所有的元素。
3. public boolean remove(E e) :把给定的对象在当前集合中删除。
4. public boolean contains(E e) :判断当前集合中是否包含给定的对象。
5. public boolean isEmpty() :判断当前集合是否为空。
6. public int size():返回集合中元素的个数。
7. public object[] toArray() :把集合中的元素,存储到数组中。

/*
    java.util.collection接口
        所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法
        任意的单列集合都可以使用Collection接口中的方法
    共性的方法:
        public boolean add(E e):把给定的对象添加到当前集合中。
        public void clear(）:清空集合中所有的元素。
        public boolean remove(E e)∶把给定的对象在当前集合中删除。
        public boolean contains(E e):判断当前集合中是否包含给定的对象。
        public booLean isEmpty():判断当前集名是否为空。
        public int size():返回集合中元素的个数。
        public object[] toArray():把集合中的元素，存储到数组中。
*/
public class Demoe1collection {
	public.static void main(string[]args) {
		//创建集合对象,可以使用多态
		//collection<string> coll = new ArrayList<>();
		collection<String> coll = new Hashset<>();
		system.out.printin(coll);//重写了tostring方法[]
        /*
		public boolean add(E e):把给定的对象添加到当前集合中。
		返回值是一个booLean值，一般都返回true,所以可不用接收
		*/
		boolean b1 = coll.add("张三");
        system.out.println("b1: "+b1);//b1:true
        system.out.println(coll);//[张三]
        coll.add("李四");
        coll.add("李四")﹔
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);//[张三，李四，赵六，田七]
        /*
            public boolean remove(E e):把给定的对象在当前集合中删除。
            返回值是一个bootean值,集合中存在元素，删除元素，返回true
            集合中不存在元素，删除失败,返回folse
        */
        boolean b2 - coll.remove("赵六")﹔
        system.out.println("b2: "+b2);//b2:true
        boolean b3 = coll.remove("赵四");
        system.out.println("b3: "+b3);//b3:false
        system.out.println(coll);//[张三，李四，田七]
        /*                         
            public boolean contains(E e):判断当前集合中是否包含给定的对象。
            包含返回true
            不包含返回false
        */
        boolean b4 = coll.contains("李四");
        system.out.println("b4: "+b4);//b4:true
        boolean b5 = coll.contains("赵四");
        system.out.println("b5:"+b5);//b5:false
        //public boolean isEmpty():判断当前集合是否为空。集合为空返回true,集合不为空返回false
        boolean b6 = coll.isEmpty();
        system.out.println("b6: "+b6);//b6:false
        // public int size():返回集合中元素的个数。
        int size = coll.size();
        system.out.println("size: "+size);//size:3
    }
}

• 小结

常用方法：

​ boolean add(E e); 向集合中添加元素

​ boolean remove(E e); 删除集合中的某个元素

​ void clear(); 清空集合所有的元素

​ boolean contains(E e); 判断集合中是否包含某个元素

​ boolean isEmpty(); 判断集合是否为空

​ int size(); 获取集合的长度

​ object[] toArray(); 将集合转成一个数组

28.Iterator接口

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口

java.util.Iterator。Iterator接口也是Java集合中的一员，但它与collection 、Map接口有所不同，collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历)collection中的元素，因此Iterator对象也被称为迭代器。

想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法∶

​ public Iterator iterator():获取集合对应的迭代器，用来遍历集合中的元素的。

迭代的概念∶
迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

lterator接口的常用方法如下:
public E next():返回迭代的下一个元素。
public boolean hasNext():如果仍有元素可以迭代，则返回true。

/*
    java.utiL.iterator接口:迭代器(对集合进行遍历)
    有两个常用的方法
        boolean hasNext(）如果仍有元素可以迭代，则返回trueo
        	判断集合中还有没有下一个元素,有就返回true,没有就返回false
        E next(）返回迭代的下一个元素。
        	取出集合中的下一个元素
    Iterator迭代器,是一个接口,我们无法直接使用，需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
    collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
    	Iterator<E> iterator();返回在此collection 的元素上进行迭代的迭代器。
    	
    迭代器的使用步骤(重点):
        1.使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
        2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
        3.使用Iterator接口中的方法next取出集合中的下一个元素
*/

public class Demoe1Iterator {
    public static void main(string[]args) {
        //创建一个集合对象
        Collection<string> coll = new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明")﹔
        coll.add("科比")﹔
        coll.add("麦迪");
        coll.add("詹姆斯")﹔
        coll.add("艾弗森");
        /*
            1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
            注意:
                Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
        */
        //多态接口实现类对象
        Iterator<String> it = coll.iterator();
        /*
            发现使用迭代器取出集合中元素的代码,是一个重复的过程
            所以我们可以使用循环优化
            不知道集合中有多少元素，使用whiLe循环
            循环结束的条件,hasNext方法返回false
        */
        while(it.hasNext()){
            string e = it.next();
            system.out.println(e);
        }
	}
}

• 迭代器实现原理：
  
  图解如上所示，其实和数组取出元素原理一致，判断下一位是否有元素，有则取出，并移动位置指针，当位置指针移动到最后一个元素时，取出元素再移动指针时，此时指针指向null，无法再取出元素。

• 增强for循环

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个lterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式:

for(元素的数据类型  变量: collection集合or数组){
//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

/*
    增强for循环:底层使用的也是迭代器,使用for循环的格式，简化了迭代器的书写
    是JDK1.5之后出现的新特性
    collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for
    public interface Iterable<T>实现这个接口允许对象成为“foreach”语句的目标。
    增强for循环:用来遍历集合和数组
    格式:
    for(集合/数组的数据类型变量名:集合名/数组名){
    	sout(变量名)﹔
    }
*/
public class Demo01Foreach {
    public static void main(string[]args) {
   		//demo01();
        //demo02();
    }
    //使用增强for循环遍历数组
    privafe static void demo01() {
        int[]arr = {1,2,3,4,5};
        for(int i :arr){
        	system.out.println(i);
        }
    }
    //使用增强for循环遍历集合
    private static void demo02(){
        ArrayList<string> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        
        for(String s : list){
        	system.out.println(s);
        }
    }

}

tips:新for循环必须有被遍历的目标。目标只能是Collection或者是数组。新式for仅仅作为遍历操作出现。