Unit 11 Java集合

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量65 收藏
点赞数
分类专栏： Java基础 文章标签： java 数据库 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63954541/article/details/130440159
版权

1 Java集合框架概述

在这里插入图片描述

在这里插入图片描述

一、集合框架的概述

​ 1.集合、数组都是对多个数据进行存储的结构，简称 Java 容器。
​ 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化层面的存储（.txt,.jpg,.avi,数据库种）

​ 2.1 数组在存储多个数据方面的特点：

  • ​ 一旦初始化以后，长度就确定了。
  • ​ 数组一旦定义好，其元素的类型也就确定了，只能操作指定类型的数据了。
    比如：String[ ] arr;int[ ] arr1;

​ 2.2 数组在存储多个数据方面的缺点：

  • ​ 一旦初始化以后，其长度就不可修改。
  • ​ 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
  • ​ 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
  • ​ 数组存储的数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二、集合框架

|-----Collection 接口：单列集合，用来存储一个一个的对象
|----List 接口：存储有序的、可重复的数据。—> “动态”数组
|----ArrayList、LinkedList、Vector
|----Set 接口：存储无序的、不可重复的数据。—> 高中讲的“集合”
|----HashSet、LinkedHashSet、TreeSet
|-----Map 接口：双列集合，用来存储一对（key-value）一对的数据—> 高中函数：y = f(x)
|----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

	@Test
	public void test1(){
		Collection coll = new ArrayList();

		//add(Objecte)：将元素e添加到集合coll中
		coll.add("AA");
		coll.add("BB");
		coll.add(123);//自动装箱
		coll.add(new Date());

		//size()：获取添加的元素的个数
		System.out.println(coll.size());

		//addAll(Collectioncoll1)：将coll1集合中的元素添加到当前的集合中
		Collection coll1 = new ArrayList();
		coll.add(456);
		coll.add("CC");
		coll.add(coll1);

		System.out.println(coll);
		System.out.println(coll.size());

		//clear()：清空集合元素
		coll.clear();

		//isEmpty()：判断当前集合是否为空
		System.out.println(coll.isEmpty());
	}

	//集合--->数组：toArray()
	Object[] arr = coll.toArray();
	for(int i =0;i < arr.length;i++){
		System.out.println(arr[i]);
	}
	//拓展：数组--->集合：调用Arrays类的静态方法asList(T...t)
	List<String> list = Arrays.asList(new String[]{"AA,BB,CC"});
	System.out.println(list);
	
	List arr1 = Arrays.asList(new int[]{123,456});
	System.out.println(arr1.size());//1
	
	List arr2 = Arrays.asList(new Integer[]{123,456});
	System.out.println(arr2.size());//2

2 Collection接口方法

1.contains(Object obj)：判断当前集合中是否包含 obj

2.containsAll(Collection coll1):判断形参 coll1 中的所有元素是否都存在于当前集合中

3.remove(Object obj):

4.removeAlll(Collection coll1):差集从当前集合中移除 coll1 中所有的元素

3 Iterator迭代器接口

在这里插入图片描述
在这里插入图片描述

集合元素的遍历操作。使用 Iterator 接口

1.内部的方法：hasNext( ) 和 next( )

2.集合对象每次调用 iterator( ) 方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

	//方式三：推荐
	Iterator iterator = coll.iterator();
		//hasNext():判断是否还有下一个元素
	while(iterator.hasNext()){
		//next():①指针下移②将下移以后集合位置上的元素返回
		System.out.println(iterator.next());
	}
	
	//错误方式一：
	Iterator iterator = coll.iterator();
	while((iterator.next()) != null){
		System.out.println(iterator.next());
	}
	
	//错误方式二：
	集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
	默认游标都在集合的第一个元素之前。
	while(coll.iterator().hasNext()){
		System.out.println(coll.iterator().next());
	}

在这里插入图片描述

	//for(集合中元素的类型 局部变量：集合对象)
	//内部调用的仍是迭代器
	for(Object obj : coll){
		System.out.println(obj);
	}

	@Test
	public void test2(){
		int[] arr = new int[]{1,2,3,4,5,6};
		//for(数组元素的类型局部变量：数组对象)
		for(int I : arr){
			System.out.println(i);
		}
	}

4 Collection子接口一：List(List是重点)

在这里插入图片描述

  1. list接口框架

​ |-----Collection 接口：单列集合，用来存储一个一个的对象
​ |----List接口：存储有序的、可重复的数据。—> “动态”数组
​ |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用 Object[ ]存储
​ |----LinkedList：对于频繁的插入和删除操作，使用此类效率比 ArrayList 高；底层使用双向链表存储
​ |----Vector：作为 List 接口的古老实现类；线程安全的，效率低；底层使用 Object[ ]存储

  1. ArrayList的源码分析：jdk7的情况下：

​ 2.1 jdk7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的 Object[]数组 elementDate
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层 elementData 数组容量不够，则扩容。
//默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数组复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayLis list = new ArrayList(int capacity)

​ 2.2 jdk8中的变化

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData
...

后续的添加与扩容操作与 jdk7 无异。

​ 2.3小结：jdk7中的 ArrayList 的创建类似于单例的饿汉式，而 jdk8 中的 ArrayList 的对象的创建类似于

单例的懒汉式，延迟了数组的创建，节省内存。

  1. LinkList 的源码分析：
LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。

//其中，Node定义为：体现了LinkedList的双向链表的说法

private static class Node<E>{
	E item;
	Node<E> next;
	Node<E> prev;

	Node(Node<E> pre, Eelement, Node<E> next){
		this.item = item;
		this.next = next;
		this.prev = prev;
	}
}

  1. Vector 的源码分析：jdk7 和 jdk8 中通过 Vector( ) 构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍。

  2. List 常用方法
    增：add(Object obj)
    删：remove(int index)（注意删除的是索引）
    remove(Object obj)（删除的是元素，new Integer(元素值)）
    改：set(int index, Object ele)
    查：get(int index)
    插：add(int index,Object ele)
    长度：size( )
    遍历：①Iterator迭代器方式
    ②增强for循环
    ③普通的循环

//方式一：Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
	System.out.println(iterator.next());
}

//方式二：增强for循环
for(数据类型 变量 ： 集合){
    sout(变量);
}
for(Object obj : list){
	System.out.println(obj);
}

//方式三：普通的for循环
for(int i=0;i<list.size();i++){
	System.out.println(list.get());
}

在这里插入图片描述

在这里插入图片描述

5 Collection子接口二：Set(Set不是重点)

在这里插入图片描述

在这里插入图片描述

Set接口的框架：
|-----Collection 接口：单列集合，用来存储一个一个的对象
|----Set 接口：存储无序的、不可重复的数据。—> 高中讲的“集合”
|----HashSet:作为 Set 接口的主要实现类；线程不安全的；可以存储null值
|----LinkedHashSet：作为 HashSet 子类，遍历其内部数据时，可以按照添加的顺序遍历
|----TreeSet：可以按照添加对象的指定属性进行排序。

1.Set 接口中没有额外定义新的方法，使用的都是 Colllection 中声明过的方法。

2.要求：向 Set 中添加的数据，其所在的类一定要重写 hashCode( ) 和 equals( )

重写的小技巧：要求：重写的 hashCode( ) 和 equals( ) 尽可能保持一致性：相等的对象必须具有相等的散列码（需要时直接 alt+shift+s 自动重写即可）

一、Set：存储无序的、不可重复的数据

​ 以 HashSet 为例说明：

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照数据的哈希值确定的。

2.不可重复性：保证添加的元素按照 equals( ) 判断时，不能返回 true，即：相同的元素只能添加一个。

二、添加元素的过程：以 HashSet 为例：

我们向 HashSet 中添加元素 a，首先调用元素 a 所在类的 hashCode( ) 方法，计算元素 a 的哈希值，

此哈希值接着通过某种算法计算出在 HashSet 底层数组中的存放位置（即为：索引位置），判断数组

此位置上是否已经有元素：

​ 如果此位置上没有其他元素，则元素 a 添加成功。—> 情况1
​ 如果此位置上有其他元素 b（或以链表形式存在的多个元素），则比较元素 a 与元素 b 的 hash 值：
​ 如果 hash 值不同，则元素 a 添加成功。—> 情况2
​ 如果 hash 值相同，进而需要调用元素 a 所在类的 equals( ) 方法：
​ equals( ) 返回 true，元素 a 添加失败
​ equals( ) 返回 false，则元素 a 添加成功。—> 情况3

对于添加成功的情况2和情况3而言：元素 a 已经存在指定索引位置上数据以链表方式存储，

​ jdk7：元素 a 放到数组中，指向原来的元素。
​ jdk8：原来的元素在数组中，指向元素 a

​ 总结：七上八下

​ HashSet底层：数组+链表的结构。

在这里插入图片描述

LinkedHashSet( )的使用
	LinkedHashSet()作为HashSet()的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
	优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
	@Test
	public void test2(){
		Set set = new LinkedHashSet();
		set.add(456); 
		set.add(123);
		set.add("AA");
		set.add("CC");
		set.add(newUser("Tom",12));
		set.add(newUser("Tom",12));
		set.add(129);
	
		//迭代器遍历
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
	/**
	Userequals()....
	456
	123
	AA
	CC
	User{name='Tom',age=12}
	129

在这里插入图片描述

1.向TreeSet中添加的数据，要求是相同类的对象。

2.两种排序方式：自然排序和定制排序

3.自然排序中，比较两个对象是否相同的标准为;compareTo( ) 返回0，不再是 equals( )

4.定制排序中，比较两个对象是否相同的标准为;compareTo( ) 返回0，不再是 equals( )。

	@Test
	public void test1(){
		TreeSet set = new TreeSet();
		//失败：不能添加不同类的对象
		//set.add(123);
		//set.add(456);
		//set.add("AA");
		//set.add(newUser("Tom",12));

		//举例一：
		//set.add(34);
		//set.add(-34);
		//set.add(43);
		//set.add(11);
		//set.add(8);

		//举例二：
		set.add(new User("Tom",12));
		set.add(new User("Jerry",32));
		set.add(new User("Jim",2));
		set.add(new User("Mike",65));
		set.add(new User("Jack",45));
		set.add(new User("Jack",56));

		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		/**
		User{name='Tom',age=12}
		User{name='Mike',age=65}
		User{name='Jim',age=2}
		User{name='Jerry',age=32}
		User{name='Jack',age=45}
		User{name='Jack',age=56}
		*/
	}
	
	@Test
	public void test2(){
		Comparator com = new Comparator(){
	//按照年龄从小到大排列
			@Override
			public int compare(Object o1,Object o2){
				if(o1 instanceof User && o2 instanceof User){
					User u1 = (User)o1;
					User u2 = (User)o2;
					return Integer.compare(u1.getAge(),u2.getAge());
				}else{
					throw new RuntimeException("输入的数据类型不匹配");
				}
			}
		};
	
		TreeSet set = new TreeSet(com);
		set.add(new User("Tom",12));
		set.add(new User("Jerry",32));
		set.add(new User("Jim",2));
		set.add(new User("Mike",65));
		set.add(new User("Jack",45));
		set.add(new User("Jack",56));
	
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		/**
		User{name='Jim',age=2}
		User{name='Tom',age=12}
		User{name='Jerry',age=32}
		User{name='Jack',age=45}
		User{name='Jack',age=56}
		User{name='Mike',age=65}
		*/
	}

6 Map接口

在这里插入图片描述

一、Map的实现类的结构

​ |----Map:双列数据，存储 key-value 对的数据—类似于高中的函数：y = f(x)
​ |----HashMap:作为 Map 的主要实现类；线程不安全的，效率高；存储 null 的 key 和 value
​ |----LinkedHashMap:保证在遍历 Map 元素时，可以按照添加的顺序实现遍历。
​ 原因：在原有的 HashMap 底层结构基础上，添加了一对指针，指向前一个和后一个元素。
​ 对于频繁的遍历操作，此类执行效率高于 HashMap。
​ |----TreeMap: 保证按照添加的 key-value 对进行排序，实现排序遍历。此时考虑 key 的自然排序或定制排序。
​ 底层使用红黑树
​ |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储 null 的 key 和 value
​ |----Properties:常用来处理配置文件。key 和 value 都是 String 类型

HashMap 的底层：数组+链表（jdk7 及之前）

​ 数组+链表+红黑树（jdk8）

面试题：

1.HashMap 的底层实现原理

2.HashMap 和 Hashtable 的异同

3.CurrentHashMap 与 Hashtable 的异同（暂时不讲）

二、Map结构的理解：

在这里插入图片描述

（key，value）–（x，y）类似函数

Map 中的 key：无序的、不可重复的，使用Set存储所有的 key—>key 所在的类要重写 equals( ) 和hashCode( )(以 HashMap 为例)。

Map中的 value：无序的、可重复的，使用 Collection 存储所有的 value—>value 所在的类要重写 equals( )。

一个键值对：key-value 构成了一个 Entry 对象。

Map 中的 entry：无序的、不可重复的，使用 Set 存储所有的 entry。

三、HashMap的底层实现原理？以jdk7为例说明：

HashMap map = new HashMap();

在实例化以后，底层创建了长度是16的一维数组 Entry[ ] table.

…可能已经执行过多次 put…

map.put(key1,value1);

首先，调用 key1 所在类的 hashCode( ) 计算 key1 哈希值，此哈希值经过某种算法以后，得到在 Entry 数组中的存放位置。

>如果此位置上数据为空，此时的 key1-value1 添加成功。 —>情况一

>如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较 key1 和已经存在的

​ 一个或多个数据的哈希值：
​ >如果 key1 的哈希值与已经存在的数据的哈希值都不相同，此时 key1-value 添加成功。—>情况二
​ >如果 key1 的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用 key1 所在类的 equals( ) 方法，比较：
​ >如果 equals( ) 返回 false：此时 key1-value1 添加成功。—>情况三
​ >如果 equals( ) 返回 true：使用 value1 替换 value2.

补充：关于情况二和情况三：此时 key1-value1 和原来的数据以链表的方式存储。

在不断地添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空时）默认的扩容方式：扩容为原来的2倍，并将原来的数据复制过来。

​ jdk8 相较于 jdk7 在底层实现方面的不同：

​ 1.new HashMap( ):底层没有创建一个长度为16的数组
​ 2.jdk8 底层的数组是：Node[ ] ,而非 Entry[ ]
​ 3.首次调用 put( ) 方法时，底层创建长度为16的数组
​ 4.jdk7 底层结构只有：数组+链表。jdk8 中底层结构：数组+链表+红黑树。
​ 当数组中的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有的数据改为使用红黑树存储。
在这里插入图片描述

四、LinkedHashMap的底层实现原理（了解）

源码中：

static class Entry<K,V> extends HashMap.Node<K,V>{
	Entry<K,V> before,after;//能够记录添加的元素的先后顺序
	Entry(int hash,K key,V value,Node<K,V> next){
		super(hash,key,value,next);
	}
}

五、Map接口中定义的方法：

在这里插入图片描述

	添加：put(Object key,Object value)
	删除：remove(Object key)
	修改：put(Object key,Object value)
	查询：get(Object key)
	长度：size()
	遍历：keySet() / values() / entrySet()
	
	public void test3(){
		HashMap map = new HashMap();
		//添加
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);
		//修改
		map.put("AA",87);
		System.out.println(map);

		HashMap map1 = new HashMap();
		map1.put("CC",123);
		map1.put("DD",123);

		map.putAll(map1);
		System.out.println(map);

		//remove(Objectkey)
		Object value = map.remove("CC");
		System.out.println(value);
		System.out.println(map);

		//clear()
		map.clear();//与map = null操作不同
		System.out.println(map.size());
	}

	public void test4(){
		HashMap map = new HashMap();
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);
		//Object get(Object key)
		System.out.println(map.get(45));
		//contains Key(Object key)
		boolean isExist = map.containsKey("BB");
		System.out.println(isExist);

		isExist = map.containsValue(123);
		System.out.println(isExist);

		map.clear();
		System.out.println(map.isEmpty());
	}
	
	public void test5(){
		HashMap map = new HashMap();
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);

		//遍历所有的key集：keySet()
		Set set = map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println();

		//遍历所有的value集：values()
		Collection values = map.values();
		for(Object obj : values){
			System.out.println(obj);
		}
		System.out.println();

		//遍历所有的key-value：entrySet()
		//方式一：
		Set entrySet = map.entrySet();
		Iterator iterator1 = entrySet.iterator();
		while(iterator1.hasNext()){
			Object obj = iterator1.next();
			Map.Entry entry = (Map.Entry)obj;
			System.out.println(entry.getKey() + "---->" + entry.getValue());
		}
		System.out.println();

		//方式二：
		Setkey Set = map.keySet();
		Iterator iterator2 = keySet.iterator();
		while(iterator2.hasNext()){
			Object key = iterator2.next();
			Object value = map.get(key);
			System.out.println(key+"---->"+value);
		}
	}

六、

在这里插入图片描述

	public class PropertiesTest{
		//Properties:常用来处理配置文件。key和value都是String类型
		public static void main(String[] args) throws Exception{
			Properties pros = new Properties();
			FileInputStream fis = new FileInputStream("jdbc.properties");
			
			pros.load(fis);//加载流对应的文件
			String name = pros.getProperty("name");
			String password = pros.getProperty("password");

			System.out.println("name = " + name + ", password = " + password);
		}
	}

7 Collections工具类

在这里插入图片描述

南方有嘉木_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java8集合源码-Java-8:Java8的练习实例和笔记
06-04
java8集合源码Lambda 表达式练习 - Koushik 在更新此文件的同时，也同时更新 Java 8 Notes Refer package for lambda exercises: com.unit1practise. - com.unit1practise.java8 : Implementing sample behavior to ...
Java集合系列详解
wang_yong_hui_1234的博客
03-25 5289
一，集合简介 Java中的集合可以分为四种体系： List：代表有序、重复的集合 Set：代表无序、不可重复的集合 Map：代表具有映射关系的集合 Queue：体系集合，代表一种队列集合实现 二，Java集合类的关系 Java中的集合类主要有两个接口派生：Collection和Map Collection类图如下： Map类图如下： 三，Collection接口 1，Set体系 Set是一种...
java集合与队列详解
幻神舞的专栏
10-30 930
说明 java集合是jdk自带java核心功能，它主要用来存储大量同类型数据快速高效稳定的查找、添加、替换，主要分为List、Set、Map、Queue，前两个继承Collection接口，Map为独立接口。 分类 Collection接口 List接口，有序可重复。 分类 ArrayList:底层是数组，默认大小10每次增加一半，线程不安全，效率高，查询快，增删慢 Vector:底层数组，查询快，增删慢，线程安全，效率低，不再使用。 方法 add(Object),add(index,
Java的集合嵌套用法
weixin_44691025的博客
05-31 2969
集合的嵌套用法 对于集合的嵌套用法，我们可以简单的化为三类，list嵌套list，list嵌套map，map嵌套map。 对于集合嵌套的赋值，我们采用由里向外赋值，对于取值相反，取值时由外向里。 1.list嵌套map 我们举map中有list的形式，即map的key为引用类型，value为list，可以写成 Map<String ,List<Person>> map =new HashMap<>(); 前面说了我们赋值时由里向外，什么是由里向外呐，就是先对里边
Java合并List集合对象的属性
靖节先生的博客
08-13 2099
Java合并List集合对象的属性1. 业务概述2. 原理分析3. 实现验证 1. 业务概述 在常见的业务需求开发中会有这样一种场景，需要的数据集合来源有3种不同的来源，并且返回的都是List集合，现在需要做的是将这3个List集合中的对象属性合并，不是集合对象合并。 例如Store对象有四个字段，id，name，location（位置），peice（价格），但是name，location，price这3个字段需要三个接口获取，分别返回三个集合List< Store >,现在就是把这三个List
Java集合容器面试题
qq_42872034的博客
02-24 1316
最新的 Java 面试题，技术栈涉及 Java 基础、集合、多线程、Mysql、分布式、Spring全家桶、MyBatis、Dubbo、缓存、消息队列、Linux…等等，会持续更新。
一张图诠释Java集合
吃果冻不吐果冻皮
10-02 1538
注：蓝色背景都是接口，非蓝色背景实现类Collection 和 Collections的区别Collection 是java.util包下的一个集合接口，它是各种集合结构的父接口。 它提供了对集合对象进行基本操作的通用接口方法。 Collection接口在Java 类库中有很多具体的实现。 Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。Collections
java 8集合处理
weixin_38285470的博客
08-17 599
1.获取对象集合的某个属性集合 List<String> ids = productSpecService.listByMap(specParams).stream().map(ProductSpecificationEntity::getId).collect(Collectors.toList()); 2.替换对象集合的某个属性值 List<SpecificationGroupDTO> groups = groupDTOList.stream().map(group -&g
scala集合和java集合的转换-List
weixin_45538732的博客
09-27 1624
scala集合和java集合的转换-List
java集合替换集合_Java集合–您必须知道的13件事
从零开始的教程世界
07-13 1381
java集合替换集合Java Collections Framework is one of the core parts of the Java programming language. Collections are used in almost every programming language. Most of the programming languages support var...
java集合及concurrent并发包整理总结
热门推荐
冯三思
02-28 3万+
1.集合包    集合包最常用的有Collection和Map两个接口的实现类，Colleciton用于存放多个单对象，Map用于存放Key-Value形式的键值对。  Collection中最常用的又分为两种类型的接口：List和Set，两者最明显的差别为List支持放入重复的元素，而Set不支持。List最常用的实现类有：ArrayList、LinkedList、Vector及Stack；Se...
java8集合源码-play-tests:用于运行UNIT和UI测试的Play框架添加（与Selenide集成，以便能够用纯Java而不是ht
06-04
java8集合源码游戏测试 Play 框架模块可轻松与 Selenide（基于 Selenium Web 驱动程序）集成，以便能够使用纯 Java 而不是 html 文件为 Play 应用程序编写 UI 测试。 将它添加到您的 dependencies.yml require: - ...
unitconverter:单位转换器服务器应用程序（Spring启动）
03-17
Java 运行单元掩盖服务器的步骤 拉项目 确保您已安装docker。 您可以使用以下命令进行检查：'docker -v' 打开cmd 导航到项目根目录 要构建项目并创建要发布的jar，请执行以下命令：'mvn clean install' 现在我们...
UnitConverter:使用 Jscience 库的单位转换器 android 应用程序
06-05
单位换算 使用 Jscience 库的单位转换器 android 应用程序 这是一个用于转换测量单位的简单应用程序。 它的主要目的是测试和试验不同的库和框架。... 番石榴过滤集合（......即使不必要，我也只是将它用于测试）。
unit-7---mini-project---part-2-KamdenRW:由GitHub Classroom创建的unit-7 --- mini-project --- part-2-KamdenRW
03-20
但是，Java数组只能表示固定大小的集合。这是一个不幸的限制，因为程序员通常不知道要预先添加多少个项目。包括Java在内的许多编程语言为程序员提供了可调整大小以及随机访问和连续的数据结构。在Java中，此数据结构...
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。
XING的博客
05-03 1198
基于Springboot的旅游管理系统（有报告）。Javaee项目，springboot项目。数据库作为系统数据储存平台，实现了基于B/S结构的Web系统。界面简洁，操作简单。采用M（model）V（view）C（controller）三层体系结构，通过。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1074
介绍了Java泛型中的重要知识点——通配泛型及其应用。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1114
Java类与对象
【Java基础】三大特性——多态
qq_43714449的博客
05-05 407
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。实现一个功能时，功能的一部分是确定的，一部分是不确定，确定的部分还会用到不确定的部分，那么就把不确定的部分暴露出去，让子类去实现。通常通过重写toString方法，来返回有用的数据。instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。确定的部分：记录一个开始时间，记录一个结束时间，结束时间 - 开始时间。对类存在的语法，对接口也存在。，返回对象的字符串表示形式。判断两个人是否是同龄人。
Java junit 测试套件
09-09
One of the key features of JUnit is test suites, which allow you to group together multiple tests and run them as a single unit. This can be useful for organizing tests into related groups and for ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值