JAVA入门学习（十六）——集合Collection、List、set

最新推荐文章于 2023-09-20 22:01:55 发布
最新推荐文章于 2023-09-20 22:01:55 发布
阅读量222 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tao_Yuanqiang/article/details/107891044
版权

java基础知识点总结（二）——Object、数组、集合、HashMap

一、Java集合框架图
在这里插入图片描述

在这里插入图片描述
二、集合与数组的区别：

					集合					    数组
长度			集合长度可变					数组长度固定
内容区别		集合只能是引用类型       		基本类型和引用类型都可以
			集合可以存储不同类型（		
元素内容		但一般也是存储一种类型，      数组只能存放一种数据类型
			使用泛型时会指定类型）

在这里插入图片描述
集合比较：
在这里插入图片描述

注意：加载因子：扩容因子=已存容量/现有容量。0.75表示当使用容量达到3/4时扩容

三、Collection集合

1.常用方法：

在这里插入图片描述
在这里插入图片描述
🔺🔺🔺🔺🔺重点：

  1. addAll（）：list1.addAll( list2 ); 这句话的意思是：将list2集合中的所有的元素都一个个的添加进list1中。这样改变了list1的元素组成，但是没有改变list2的元素组成。

  2. removeAll（）： list1.remove(list2) ; 这句话的意思是：list1集合与list2集合 先 找到 交集，然后 在 list1中删除 交集 ，然后将删除交集后的list1重新赋给list1，list2中的元素不变，然后打印list1，这样就会输出 删除交集后的 list1 。 removeAll删除的是 两个集合的交集 。

  3. containsAll（）: boolean flag = list1.containAlls(list2) ; 查看 list1中是否包含所有的list2中的元素，如果 list1 集合中 包含所有 的 list2集合中所有的元素，那么就返回 true ，否则返回 false 。

  4. retainAll（）: boolean flag = list1.retainAll(list2) ; list1 和 list2 两个集合 先取 交集 。 然后 将交集 赋给 list1 ， 如果 list1集合元素组成发生了变化，那么就返回 true ，否则返回 false 。 特殊情况： list1 和 list2 两个集合 完全相同，所以 list1 和list2 的交集 就是他们 本身，把交集 赋给 list1时 ，list1 没有发生任何的变化，所以返回 false 。
    综上所述：retainAll（）中 ，只要list1发生变化，就返回 true，不发生变化就返回false 。

代码描述：

package cn.rjxy.tao16.Test01;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 测试Collection接口的常用方法
 * @author 陶沅玱
 *
 */
public class Test1 {

	// 测试collection接口的常用方法
	public static void main(String[] args) {
		Collection<String> coll = new ArrayList<String>();
//		Collection<Integer> coll1=new ArrayList<>();
//		coll1.add(1);
		coll.add("你好");
		coll.add("java");
		// 测试是否为空，如果集合没有元素那个集合就是空,返回true，有元素返回false
		boolean b = coll.isEmpty();
		System.out.println(coll); // [你好, java]
		System.out.println(b); // false
		// 返回集合元素的个数
		System.out.println(coll.size()); //2
		// 集合是否包含这个元素 ,有则返回true
		System.out.println(coll.contains("java"));  //true
		// 删除元素,删除成功返回true
		System.out.println(coll.remove("java")); //true
		System.out.println(coll.size());  //1
		// 清空元素
		coll.clear();
		System.out.println(coll.isEmpty()); //true

	}
}


package cn.rjxy.tao16.Test01;

import java.util.ArrayList;
import java.util.Collection;

public class Test3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection<String> c1 = new ArrayList<>();
		c1.add("c");
		c1.add("c++");
		c1.add("java");
		Collection<String> c2 = new ArrayList<>();
		c2.add("jsp");
		c2.add("php");
		boolean b = c1.contains(c2);
		System.out.println(b); //false
		
		//把c2的数据都值给c1,
		c1.addAll(c2);
		c1.forEach(a -> System.out.print(a + "\t"));  //c	c++	java   jsp	php
		System.out.println(); 
		
		//从c1中移除与c2相同的元素（指地址相同）
		c1.removeAll(c2);
		c1.add("java");
		c1.forEach(a -> System.out.print(a + "\t"));  //c	c++	java	java	
		System.out.println();
		
		c1.removeAll(c2);
		c1.forEach(a -> System.out.print(a + "\t"));  //c	c++	java	java	


	}
}

2.遍历集合的三种方式：

package cn.rjxy.tao16.Test01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;

/**\
 * 	遍历Collection接口的三种方式
 * @author 陶沅玱
 *
 */
public class Test2 {

	public static void main(String[] args) {
		Collection<String> coll = new ArrayList<String>();
		coll.add("你好");
		coll.add("java");
		
		// 遍历集合，1.增强for循环
		for (String str : coll) {
			System.out.println(str);
		}
		
		// 遍历集合，2迭代器
		Iterator<String> it = coll.iterator();
		// .hasNext()判断当前集合里面是否有元素，有就返回true 
		// .next()返回下一个元素
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		
		// 遍历集合，3.lambda表达式
		coll.forEach(e -> System.out.println(e));
		//方式三的匿名内部类表达上市
		coll.forEach(new Consumer<String>() {
			
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		});
		System.out.println();
		//也是lambda表达式
		coll.forEach(System.out::println);
		
	}

}

四、ArrayList集合

List集合的特征：List的特征是其元素以线性方式存储，集合中可以存放重复对象。

1.定义

实现了List接口，代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与删除元素的速度慢。

2.创建方式

//定义存放String类型的集合
List<String> list = new ArrayList<>();

3.使用方法

同Collection集合的操作一样

package cn.rjxy.tao16.Test02;

import java.util.ArrayList;
import java.util.List;

public class Test1 {

	public static void main(String[] args) {
		
		List<String> list = new ArrayList<>();
		list.add("hello");
		list.add(0, "abc");
		list.forEach(e -> System.out.print(e + "\t")); //abc hello
		System.out.println();
		
		//修改hello
		list.set(1, "111");
		list.forEach(e -> System.out.print(e + "\t")); //abc 111
		System.out.println();
		
		//删除
		list.remove(0);
		list.forEach(e -> System.out.print(e + "\t")); //111
		System.out.println();
		
		System.out.println(list.get(0)); //111
	}
}

4.ArrayList集合与数组的转换

package cn.rjxy.tao16.Test02;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 集合与数组的转换
 * @author 陶沅玱
 *
 */
public class Test3 {

	//把集合转换成数组
	public static void test1() {
		//创建一个集合
		List<Integer> list1 = new ArrayList<>();
		list1.add(2);
		list1.add(5);
		list1.add(8);
		
		//方法一：把集合转换成数组 toArray()->该方法返回的是一个 Object类型的数组
		//Integer[] intArray = (Integer)list1.toArray();   编译时不会报错，运行时报错java.lang.ClassCastException
		Object[] objArray = list1.toArray();
		System.out.println(Arrays.toString(objArray)); // [2, 5, 8]
		
		//方法二：toArray(T[] t); 在方法参数中指定数组类型，返回值即为该类型数组
		Integer[] intArray = list1.toArray(new Integer[list1.size()]);
		System.out.println(Arrays.toString(intArray));  // [2, 5, 8]
		
		List<String> list2 = new ArrayList<>();
		list2.add("hello");
		list2.add(0, "java");
		
		String[] strArray = list2.toArray(new String[list2.size()]);
		System.out.println(Arrays.toString(strArray)); //[java, hello]
	}
	
	
	//把数组转换成集合
	public static void test2() {
		
		List<String> list1 = Arrays.asList("java", "hello", "tao");
		System.out.println(list1); //[java, hello, tao]
		//用这种方式生成的集合不能使用add、remove等方法，
		//list1.add("xx"); 编译时不报错，运行时报错java.lang.UnsupportedOperationException
	}
	
	public static void main(String[] args) {
		test2();
	}
}

5.给集合进行排序

注意：Arrays.sort(数组)
Collections.sort(List)

	//给集合进行排序
	public static void test2() {
		
		List<String> list1 = Arrays.asList("java", "hello", "tao");
		System.out.println(list1); //[java, hello, tao]
		//用这种方式生成的集合不能使用add、remove等方法，
		//list1.add("xx"); 编译时不报错，运行时报错java.lang.UnsupportedOperationException
		
		//给集合排序，使用Collections类中的sort方法
		Collections.sort(list1);
		System.out.println(list1);  //[hello, java, tao]
		
		//排序的两种方式
		//Comparable(在类内部实现，使类直接及实现该接口) 和 Comparator
		//https://www.cnblogs.com/szlbm/p/5504634.html
		list1.sort(new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o1.compareTo(o2);
			}
		});
		System.out.println(list1);  //[hello, java, tao]
	}

🔺使用Comparable、 Comparator进行排序

<1.Comparator

Comparator可以认为是是一个外比较器，个人认为有两种情况可以使用实现Comparator接口的方式：
1、一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较
2、一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式

Comparator接口里面有一个compare方法，方法有两个参数T o1和T
o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：
1、o1大于o2，返回正整数
2、o1等于o2，返回0
3、o1小于o3，返回负整数

▲案例：

按照学生成绩排序
1.定义Student类
    两个变量：name,score
    方法：
2.定义集合，3个student对象，添加到集合
3.使用sort方法排序，排序是指定排序规则
4.输出排序后的集合

package com.rjxy.day16.Test2;

public class Student {

	private String name;
	private int grade;
	
	public Student(String name, int grade) {
		super();
		this.name = name;
		this.grade = grade;
	}

	public String getName() {
		return name;
	}

	public int getGrade() {
		return grade;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", grade=" + grade + "]";
	}
	
}


package com.rjxy.day16.Test2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {

	public static void main(String[] args) {
		
		List<Student> stuList = new ArrayList<>();
		stuList.add(new Student("张三", 89));
		stuList.add(new Student("李四", 97));
		stuList.add(new Student("王五", 60));
		
		//方法一
//		stuList.sort(new Comparator<Student>() {
//
//			@Override
//			public int compare(Student o1, Student o2) {
//				// TODO Auto-generated method stub
				//按成绩正序排序
//				return o1.getGrade() - o2.getGrade();
				//按成绩逆序排序
//				return o2.getGrade() - o1.getGrade();
//			}
//			
//		});
//		System.out.println(stuList);
		
		//方法二
		Collections.sort(stuList, new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				// TODO Auto-generated method stub
				return o2.getGrade() - o1.getGrade();
			}});
		System.out.println(stuList);
	}
}

<2.Comparable

Comparable可以认为是一个内比较器，实现了Comparable接口的类有一个特点，就是这些类是可以和自己比较的，至于具体和另一个实现了Comparable接口的类如何比较，则依赖compareTo方法的实现，compareTo方法也被称为自然比较方法。如果开发者add进入一个Collection的对象想要Collections的sort方法帮你自动进行排序的话，那么这个对象必须实现Comparable接口。compareTo方法的返回值是int，有三种情况：

1、比较者大于被比较者（也就是compareTo方法里面的对象），那么返回正整数

2、比较者等于被比较者，那么返回0

3、比较者小于被比较者，那么返回负整数

package com.rjxy.day16.Test3;

//直接在内部类实现排序
public class Student implements Comparable<Student> {

	private String name;
	private int grade;

	public Student(String name, int grade) {
		this.name = name;
		this.grade = grade;
	}
	
	@Override
	public String toString() {
		return "Student [name=" + name + ", grade=" + grade + "]";
	}
	
	//在该方法内完成排序
	@Override
	public int compareTo(Student o) {
		return this.grade - o.grade;
	}

	public String getName() {
		return name;
	}

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

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}

}


package com.rjxy.day16.Test3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {

	public static void main(String[] args) {
		
		List<Student> stuList = new ArrayList<>();
		stuList.add(new Student("张三", 89));
		stuList.add(new Student("李四", 97));
		stuList.add(new Student("王五", 60));
		
		System.out.println("直接在Student方法内完成排序:");
		Collections.sort(stuList);
		System.out.println(stuList);
		//[Student [name=王五, grade=60], Student [name=张三, grade=89], Student [name=李四, grade=97]]
	}
}

重要！！！重要！！！重要！！！

🔺🔺🔺自定义实现ArrayList底层（仅可以接收String类型）

package com.rjxy.day16.Test4;

import java.util.Arrays;

/**
 * 实现ArrayList
	MyArray      (String)
	int size;//表示集合的元素个数
	String[] strArray;
	1.定义无参的构造方法  默认给数组10个
	MyArray()
	2.定义一个带参的构造方法
	MyArray(int length);
	3.add(String str);
		判断元素的个数和数组的长度之间的关系  size>=strArray 扩容
		添加元素
		size++;		
	4.定义grow方法
		规则:数组长度的一半(如果数组长度为1 ,扩容应该是+1)
	5.add(int index,String str)
		判断元素的个数和数组的长度之间的关系  size>=strArray 扩容
		当前的数组元素后移
		插入元素
		size++;
	6.remove(int index)
		当前的数组元素前移
		size--;
	7.set(int index,String str):修改
	8.get(int index):获取元素
        9.size():返回集合中的元素个数
 * @author 陶沅玱
 *
 */
public class StrArrayList {

	//表示集合中的元素个数
	private int size;
	
	//定义一个数组
	private String[] strArray;
	
	public StrArrayList() {
		//默认给数组初始值10
		strArray = new String[10];
	}
	
	//可以自己定义数组的长度
	public StrArrayList(int length) {
		strArray = new String[length];
	}
	
	//添加元素
	public void add(String str) {
		//ArrayList的扩容因子是1，即元素满了，收到下一个元素再扩容
		if(size >= strArray.length) {
			//扩容
			grow();
		}
		//存储数据到最后一位,size的初始值为0
		strArray[size] = str;
		size++;
	}
	
	//进行数组的扩容
	//ArrayList的扩容规则:数组长度的一半
	public void grow() {
		if(strArray.length <= 1) {
			//            要扩容的目标数组        长度
			Arrays.copyOf(strArray, strArray.length + 1);
		}
		Arrays.copyOf(strArray, (strArray.length + strArray.length/2));
	}
	
	//指定位置插入元素
	public void add(int index, String str) {
		if(size >= strArray.length) {
			grow();
		}
		//{1,4,7,9}    插入位置：1       需要右移的元素个数：3
 		//{1, , 4,7,9}        4-1 = 3
		
		//实现数组的拷贝
		System.arraycopy(strArray, index, strArray, index+1, size-index);
		strArray[index] = str;
		size++;
	}
	
	//删除指定位置的元素
	public void remove(int index) {
		if(index >= size) {
			try {
				throw new Exception("下标异常");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//{1,4,5,6} 删除位置：1   需要左移的元素个数：2
		//{1,5,6}        4-1-1=2
		//实现数组的拷贝
		System.arraycopy(strArray, index+1, strArray, index, size-1-index);
		size--;
	}
	
	//修改指定位置的元素内容
	public void set(int index, String str) {
		strArray[index] = str;
	}
	
	//获取指定位置的元素
	public String get(int index) {
		return strArray[index];
	}
	
	//获取集合中元素的个数
	public int size() {
		return size;
	}
}


package com.rjxy.day16.Test4;


public class Test {

	public static void main(String[] args) {
		
		StrArrayList a = new StrArrayList(4);
		
		a.add("hello");
		a.add("java");
		
		for(int i=0; i<a.size(); i++) {
			System.out.print(a.get(i) + "\t");  //hello	java
		}
		System.out.println();
		
		a.add(0, "hhhhh");
		a.add(1, "ggggg");
		for(int i=0; i<a.size(); i++) {
			System.out.print(a.get(i) + "\t");  //hhhhh	ggggg	hello	java
		}
		System.out.println();
		a.remove(0);
		for(int i=0; i<a.size(); i++) {
			System.out.print(a.get(i) + "\t");  //ggggg	hello	java
		}
		System.out.println();
		System.out.println(a.size()); //3
	}
}
Tao_Yuanqiang
关注
专栏目录
学JAVA 泛型 Collection List Set
weixin_57848462的博客
12-27 122
集合 我们接下来要学习的内容是Java基础中一个很重要的部分：集合 1 Collection接口 1.1 集合前言 Java语言的java.util包中提供了一些集合类,这些集合类又称之为容器 提到容器不难想到数组,集合类与数组最主要的不同之处是,数组的长度是固定的,集合的长度是可变的，而数组的访问方式比较单一,插入/删除等操作比较繁琐,而集合的访问方式比较灵活 常用的集合类有List集合,Set集合,Map集合,其中List集合与Set集合继承了Collection接口,各个接口还提供了不同的实
Java学习笔记十七——集合类详细总结各自对比
Pandafz的博客
10-12 4202
一、Java集合介绍
Java语言基础——List集合、Set集合
菜鸟小梦的博客
09-07 323
文章目录1. 数据结构1.1 栈 Stack1.2 队列 Queue1.3 数组 Array1.4 链表 Link1.5 红黑树2. List集合2.1 ArrayList集合2.2 LinkedList集合3. Set接口3.1 HashSet集合3.2 LinkedHashSet集合3.3 TreeSet集合4. 可变参数 1. 数据结构 当你用着java里面的容器类很爽的时候，你有没有想过，怎么ArrayList就像一个无限扩充的数组，也好像链表之类的。好用吗？好用，这就是数据结构的用处，只不过你在不
Java基础入门之——集合类
qq_53308984的博客
07-22 322
java集合，list，set，map
Java基础知识总结 ——集合
Xiaowei's Blog
04-22 308
1. List List是有序的Collection，List一共有三个实现类：ArrayList、Vector和LinkedList。 1.1. ArrayList ArrayList内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元...
JAVA入门—————Collection集合 AND 子子接口ArrayList AND 数据结构
qq_45673367的博客
11-07 185
集合 定义：方便增删改查容器中的元素 是一种容器 数组和集合的区别 数组： 长度固定 存储基本数据类型和引用数据类型 储存同类型数据 集合： 长度可变 存储引用数据类型 可以存储不同类型数据 Collection集合 定义：是集合的顶层父接口 子接口：set 和 list ArrayList： List接口的子接口 添加功能 boolean add(Objec...
JavaSE入门——集合Collection
明光
08-04 150
文章目录Collection Collection 在集合的继承体系中，collection可以说是最大的，它下面有list和set（子孙类），因此，collection中定义的方法规定是list和set都有的。 集合中只能存储单个元素，且只能保存引用数据类型的数据，保存 ...
Java入门第三季——集合
最新发布
m0_74981829的博客
09-20 54
1.课程类2.学生类构造器。
Java基础学习——第十一章 Java集合
weixin_47392089的博客
04-09 1122
Java基础学习——第十一章 Java集合 一、Java集合框架概述 1. Java容器：数组与集合 面向对象编程对事物的体现都是以对象的形式，为了便于对多个对象进行操作，就要对对象进行存储 Java容器：集合和数组都是对多个数据进行存储(内存层面)的结构；① 数组在存储对象方面存在着一些弊端；② 集合可以动态地把多个对象的引用放入容器中 数组在存储多个数据方面的弊端： 数组一旦初始化以后，长度就不可变了，不便于扩展 数组一旦声明类型后，其元素的类型也就确定了，不能再存储其他类型的数据（多态情况除外）
JAVA-SE入门学习——第八讲集合
06-08
以上内容涵盖了Java集合框架的基础知识，包括Collection接口、Set接口、List接口、Map接口的理解和使用，以及泛型、集合与数组的转换、集合的遍历和复制等重要概念。在实际开发中，掌握这些知识对于编写高效、安全的...
Java入门到精通——第二十三单元 Map集合
weixin_50009850的博客
03-25 628
第二十三单元 Map集合本章目标一．Map集合1.集合的介绍2.HashMap3.LinkedHashMap4.Map常用方法介绍5.键找值方式演示6.获取Entry键和值的方式7.获取Entry键值对方式8.HashMap存储练习9.LinkedHashMap的特点10.Map案例讲解二. 补充知识点1.JDK9版本的特性2.学会使用DEBUG三. 模拟斗地主洗牌、发牌1.斗地主案例规则介绍2.斗地主案例解析 本章目标 map集合的使用 HashMap的使用 LinkedHashMap的使用 斗地主案例
21、JAVA进阶——集合（2）
不迁怒，不贰过。小知识，大智慧。
09-28 861
一、Collections类 1、解释 2、对集合元素排序与查找 3、替换集合元素 二、认识泛型 1、 泛型的定义 2、 泛型在集合中的应用 三、深入泛型 1、 定义泛型类、泛型接口和泛型方法 2、 多个参数的泛型类 3、 从泛型类派生子类
eclipse 中导入jar包时 classpath与moduelepath的区别，jia包应该放到哪个下
Tao_Yuanqiang的博客
10-15 7317
首先，导入jar包时，必须导入到 classpath下， 若导入到moduelpath下，在进行 import 导入接口时，会出错（找不到该接口） classpath与moduelepath的区别： ModulePath 的概念和ClassPath 类似，不过 ModulePath 中的 Jar 包或 Jmod 文件被当作 Module 来处理，而 ClassPath 中的的 Jar 包，无论是...
（简单实例）使用cmd在桌面创建文件夹，并在该文件夹中使用cmd编译和运行一个java程序段（详细的了解java的跨平台运行原理）
Tao_Yuanqiang的博客
05-13 2180
使用cmd在桌面创建文件夹，并在该文件夹中使用cmd编译和运行一个java程序段** 1.使用快捷键win+r打开 2.使用 cd desktop 指令进入到根目录（桌面） 在此。你可以使用 dir指令查看 桌面下所有的目录 3.使用 md mybatis在桌面上创建一个名为mybatis的文件夹( cd mybatis 可用来删除mybatis文件夹) 4.使用cd mybatis 指令...
JAVA提升（六）——字符串在JVM中存放的位置（常量池）
Tao_Yuanqiang的博客
08-16 1491
常量池的作用: 在Java中只要是new的信息都会在堆上开辟一个新的空间,为了解决这个问题,JVM中才出现了字符串常量池的概念。但是只有直接用 ""修饰的字符,才会被加入到常量池中,当再次用 ""创建的时候,会首先从常量池中去获取。 字符串常量池存在于运行时常量池中。也就存在于方法区中。（此处关于字符串常量池存放位置，网上也有说是在堆中！我也不是清楚。。。） String 的特性： <1、String类代表字符串。 Java 程序中的所有字符串面值（如 “abc” ）都作 为此类的实例现。 &l
JAVA入门学习（十七）——泛型、Stream（流）详解
Tao_Yuanqiang的博客
08-13 1021
一、泛型 1.定义： 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别
JAVA入门学习（十二）——输入流、输出流详解
Tao_Yuanqiang的博客
07-30 670
一、IO 1.IO->Input Output Java里面分为两种流：字节流和字符流。如果细分的话有，可分为：4个文件流，4个缓冲流，2个转换流，2个打印流，2个序列化流，2个数据流。 Stream表示基于字节流，Writer和Reader表示基于字符流 //文件流 FileInputStream //字节输入流 FileOutPutStream //字节输出流 FileReader //字符输入流 FileWrite
JAVA入门学习（十九）—— 读写XML文件内容，自定义注解Annotation的实现
Tao_Yuanqiang的博客
08-10 489
一、XML 1.读写XML文件的内容 1.1 定义一个Xml文件，读出里面的内容 <?xml version="1.0" encoding="UTF-8"?> <emps> <emp id="0001"> <!-- id为emp节点的属性节点，获取值的方式为getValue() --> <name>tao</name> <age>18</age> <!-- name、age、s
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值