Java基础之集合

2023-10-29

Java基础

集合

1.Collection接口
Collection 是 List 和 Set 的父接口。
常用方法如下：

package com.java.day16;

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

/**
 *测试Collection接口的常用方法
 */
public class Demo {
	/**
	 * 范型是jdk 5.0以后有的
	 * Collection<String> coll = new ArrayList<String>();
	 * 后面的<>里可以不写
	 * Collection<String> coll = new ArrayList<>();
	 * <>里必须装引用类型
	 */
	public static void main(String[] args) {
		Collection<String> coll1 = new ArrayList<>();
		Collection<Integer> coll2 = new ArrayList<>();
		coll2.add(1);
		//add()添加
		coll1.add("hello");
		coll1.add("zhou");
		//isEmpty()判断集合有没有元素
		boolean b = coll1.isEmpty();
		System.out.println(b);
		//size()容器里元素个数
		System.out.println(coll1.size());
		//判断集合中是否包含元素
		System.out.println(coll1.contains("hello"));
		//删除元素
		coll1.remove("hello");
		System.out.println(coll1.size());
		//清空容器
		coll1.clear();
		System.out.println(coll1.size());
		
	}

}

package com.java.day16;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 *遍历集合的方法
 */
public class Demo2 {
	public static void main(String[] args) {
		Collection<String> coll1 = new ArrayList<>();
		coll1.add("hello");
		coll1.add("zhou");
		coll1.add("lala");
		
		//第一种方法   增强for循环
		for(String str : coll1) {
			System.out.println(str);
		}
		System.out.println("=======================================");
		//第二种方法   迭代器
		Iterator<String> it = coll1.iterator();
		while(it.hasNext()) {
			String str = it.next();
			System.out.println(str);
		}
		System.out.println("=======================================");
		//第三种   lambda表达式
		coll1.forEach(a->System.out.println(a));
	}
}

package com.java.day16;

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

/**
 *和集合相关的方法
 */
public class Demo3 {
	
	public static void main(String[] args) {
		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");
		c2.add("java");
		//c1集合中是否包含c2
		System.out.println(c1.containsAll(c2));
		//c1中添加c2
		c1.addAll(c2);
		c1.forEach(str->System.out.println(str));
		//c1中删除c2
		c1.removeAll(c2);
		c1.forEach(str->System.out.println(str));
		
		
	}
}

List接口
有序的、元素可重复
2.1 ArrayList
线性表
底层实现是数组，默认容量为10，容量不够进行扩容。
常用方法如下：

package com.java.day16;

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

/**
 *ArrayList常用方法
 */
public class Demo4 {

	public static void main(String[] args) {
		List<String> list = new ArrayList<>();
		//添加
		list.add("hello");
		list.add(0, "add");
		list.forEach(str->System.out.println(str));
		//修改
		list.set(1, "1111");
		list.forEach(str->System.out.println(str));
		//删除
		list.remove(0);
		list.forEach(str->System.out.println(str));
		System.out.println("===========================");
		for(int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}

package com.java.day16;

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

public class Demo5 {
	//集合转换成数组
	public static void test1(){
		List<String> list = new ArrayList<>();
		list.add("hello");
		list.add(0, "add");
		
		List<Integer> list2 = new ArrayList<>();
		list2.add(1);
		list2.add(2);
		list2.add(12);
		list2.add(23);
		
		Object[] obj = list2.toArray();
		
		int sum = 0;
		for(Object o : obj) {
			sum += (Integer)o;
		}
		
		Integer[] li = list2.toArray(new Integer[list2.size()]);
		for(Integer i : li) {
			sum += i;
		}
		Arrays.sort(li);
		System.out.println(Arrays.toString(li));
		
		String[] strs = list.toArray(new String[list.size()]);
		Arrays.sort(strs);
		System.out.println(Arrays.toString(strs));
	}
	
	static Comparator<String> com = new Comparator<String>() {
		public int compare(String o1, String o2) {
			return o1.length() - o2.length();
		};
	};
	
	//数组转换成集合
	//注意：给集合排序使用的是Collections的sort方法
	public static void test2() {
		String[] str = {"hello", "abeeec", "fhhhgff"};
		
		List<String> list = Arrays.asList(str);
		//使用默认的排序规则
		Collections.sort(list);
		System.out.println(list);
		//重新定义排序规则
		//Collections.sort(list, com);
		Collections.sort(list, (o1, o2) -> o1.length() - o2.length());
		System.out.println(list);
	}
	
	public static void main(String[] args) {
		//test1();
		test2();
	}

}

练习
按照学生成绩排序--------有两种方法，下面的代码将两种方法写在了一起。
第一种方法：使用的是Collections的sort方法自定义排序，第二个参数传递Comparator的实现类；
第二种方法：要排序的类实现Comparable接口，重写compareTo方法，再使用Collections的sort方法传递一个参数。

package com.java.day16;

public class Student {
	private String name;
	private int score;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", score=" + score + "]";
	}

}

package com.java.day16;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
 *练习：按照学生成绩排序
 */
public class Test {
	
	public static void main(String[] args) {
		//排序第一种方法
		List<Student> list = new ArrayList<Student>();
		list.add(new Student("张三", 80));
		list.add(new Student("李四", 90));
		list.add(new Student("王五", 95));
		Collections.sort(list, (o1, o2)-> o1.getScore() - o2.getScore());
		System.out.println(list);
		
		//list.forEach(stu-> System.out.print(stu.getName()+" "));
		//排序第二种方法
		List<Student2> list2 = new ArrayList<Student2>();
		list2.add(new Student2("张三", 80));
		list2.add(new Student2("李四", 90));
		list2.add(new Student2("王五", 95));
		Collections.sort(list2);
		System.out.println(list2);
	}

}

package com.java.day16;

public class Student2 implements Comparable<Student2>{
	private String name;
	private int score;
	public Student2() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student2(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", score=" + score + "]";
	}
	@Override
	public int compareTo(Student2 o) {
		return this.score - o.score;
	}

}

泛型
java泛型设计原则：编译不出错，运行时就不会出现类型转换异常。
3.1 泛型类
class TestObj< T >{
private T obj;
private int age;
private String name;
…
}
如果想用一个类来描述学生和员工，学生有学号的属性，员工有工资的属性，那么就可以使用泛型类，代码如下：

	package com.java.day17;
	
	public class TestObj<T> {
		private T data;
		private String name;
		
		public TestObj() {
			super();
			// TODO Auto-generated constructor stub
		}
		
		public TestObj(T data, String name) {
			super();
			this.data = data;
			this.name = name;
		}
	
		public T getData() {
			return data;
		}
		public void setData(T data) {
			this.data = data;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
	
		@Override
		public String toString() {
			return "TestObj [data=" + data + ", name=" + name + "]";
		}
		
	}

	package com.java.day17;
	
	public class Demo1 {
		public static void main(String[] args) {
			TestObj<String> stu = new TestObj<>();
			stu.setName("zhou");
			stu.setData("20171612245");
			System.out.println(stu);
			
			TestObj<Double> emp = new TestObj<>();
			emp.setName("张三");
			emp.setData(12000.5);
			System.out.println(emp);
		}
	}

3.2 泛型方法
泛型方法所在的类不一定是泛型类。

	//泛型方法------输出任意数据类型的数组元素
	public static <T> void showData(T[] a) {
		for(T t : a) {
			System.out.print(t+" ");
		}
	}

3.3 泛型接口
interface Inf< T >{
}

	package com.java.day17;
	//泛型接口
	interface Demo2Inter<T>{
		void show(T t);
	}
	//子类明确了泛型接口的数据类型
	class Demo2Impl1 implements Demo2Inter<String>{
		@Override
		public void show(String t) {
			System.out.println(t);
		}
	}
	//子类不明确泛型接口的数据类型
	class Demo2Impl2<T> implements Demo2Inter<T>{
	
		@Override
		public void show(T t) {
			System.out.println(t);
		}
		
	}
	public class Demo2 {
	
		public static void main(String[] args) {
			Demo2Inter<String> di1 = new Demo2Impl1();
			di1.show("di1");
			Demo2Inter<String> di2 = new Demo2Impl2<>();
			di2.show("di2");
		}
	
	}

3.4 泛型的使用—通配符
通配符---- ？表示任意数据类型
List< Object >和List< String >不存在继承关系，代码如下：

	package com.java.day17;
	
	import java.util.ArrayList;
	import java.util.List;
	
	public class Demo3 {
		
		public static void test(List<Object> list) {
			for(Object object : list) {
				System.out.println(object);
			}
		}
		
		public static void main(String[] args) {
			//List<Object> list = new ArrayList<>();
			List<String> list = new ArrayList<>();
			list.add("a");
			list.add("b");
			list.add("c");
			//test(list);//报错，因为List< Object >和List< String >不存在继承关系
			
		}
	
	}

	package com.java.day17;
	
	import java.util.ArrayList;
	import java.util.List;
	
	public class Demo3 {
		
		public static void test(List<?> list) {//使用了通配符，表示任意数据类型
			for(Object object : list) {
				System.out.println(object);
			}
		}
		
		public static void main(String[] args) {
			//List<Object> list = new ArrayList<>();
			List<String> list = new ArrayList<>();
			list.add("a");
			list.add("b");
			list.add("c");
			test(list);
			
		}
	
	}

3.5 设置通配符的上限
List<? extends Number>

package com.java.day17;

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

public class Demo3 {

	//通配符的上限
	public static void test2(List<? extends Number> list) {
		for(Number number : list) {
			System.out.println(number);
		}
	}
	
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		test2(list);
	}

}

3.6 设置通配符的下限
List<? super Number>

package com.java.day17;

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

public class Demo3 {
	//通配符的下限
		public static void test3(List<? super Number> list) {
			for(Object number : list) {
				System.out.println(number);
			}
		}
	public static void main(String[] args) {
		List<Object> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		test3(list);
	}
}

3.7 通配符的错误使用
class A<?>{}
public <?> void t(List<?> list){}
List<?> list = new ArrayList<?>();

Stream类型
和io没有任何关系
流式思想：像生产流水线一样，一个操作接一个操作。
使用流操作集合更高效
4.1 Stream的特性
1.stream不存储数据
2.stream不改变源数据
3.stream的延迟执行特性
4.2 使用Stream流的步骤
数据源→转换成流→操作1→操作2→……
数据源（source）：可以是集合、数组等。
获取流：

	public static void test1() {
		List<String> list = new ArrayList<>();
		list.add("a");
		list.add("b");
		//把集合变成了流
		Stream<String> stream1 = list.stream();
		
		Integer[] num = {1, 2, 3};
		//把数组变成流
		Stream<Integer> stream2 = Stream.of(num);
		
		stream2.forEach(e->System.out.println(e));
		//stream2.forEach(e->System.out.println(e));//报错，流只能使用一次
		
	}

4.3 流的常用方法

	//stream常用方法
	public static void test2() {
		//filter 方法用于通过设置的条件过滤出元素
		Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6,7,8);
		Stream<Integer> numStream = stream2.filter(e -> e % 2 != 0);
		numStream.forEach(e -> System.out.println(e));
		System.out.println("================================");
		//2.map 方法用于映射每个元素到对应的结果
		stream2 = Stream.of(1,2,3,4);
		stream2.map(e -> e * e).forEach(e -> System.out.println(e));
		System.out.println("================================");
		//3.limit 方法用于获取指定数量的流
		stream2 = Stream.of(1,2,3,4);
		stream2.limit(3).forEach(e -> System.out.println(e));
		System.out.println("================================");
		//4.跳过前n个stream.skip
		stream2 = Stream.of(1,2,3,4);
		stream2.skip(2).forEach(e -> System.out.println(e));
		System.out.println("================================");
		//5.返回数量count
		stream2 = Stream.of(1,2,3,4);
		System.out.println(stream2.count());
		System.out.println("================================");
		//6.流的连接Stream.concat（stream1,stream2）
		stream2 = Stream.of(1,2,3,4);
		Stream<Integer> stream3 = Stream.of(5,6,7,8);
		Stream.concat(stream2, stream3).forEach(e -> System.out.println(e));
		System.out.println("================================");
		//7.可以把流转换为 List 类型:collect(Collectors.toList());
		stream2 = Stream.of(1,2,3,4);
		System.out.println(stream2.collect(Collectors.toList()));
		System.out.println("================================");
		//8.求和的方法reduce(0, (x, y) -> x + y)
		stream2 = Stream.of(1,2,3,4);
		System.out.println(stream2.reduce(0, (x, y) -> x + y));
		System.out.println("================================");
		//9.去重distinct()
		stream2 = Stream.of(1,2,3,4,3);
		stream2.distinct().forEach(e -> System.out.println(e));
		System.out.println("================================");
		//10.排序：sorted()
		stream2 = Stream.of(1,4,3,2);
		stream2.sorted().forEach(e -> System.out.println(e));
	}

List集合的实现类
Linkedlist (线程不安全) 和 Vector (线程安全)
5.1 Linkedlist
双向链表
Linkedlist 和 Arraylist 都是线程不安全的
5.2 Vector
Vector 是线程安全的
Set集合
无序、元素不重复
不重复：先判断hashCode()，再判断equals()，如果返回true，表示一个对象，否则是不同对象。
6.1 hashSet
HashSet基于HashMap的实现，HashSet的元素是map中的key。

	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		set.add("张三");
		set.add("张三");
		set.add("李四");
		set.add("王五");
		set.remove("王五");
		set.forEach(System.out::println);
	}

6.2 TreeSet
会排序
TreeSet的元素必须是有排序规则的对象，否则会运行时异常

package com.java.day17;

import java.util.TreeSet;
class Emp{
	private String name;
	private int age;
	public Emp() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Emp(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Emp [name=" + name + ", age=" + age + "]";
	}
	
}
public class Demo7 {
	public static void test1() {
		TreeSet<String> set = new TreeSet<>();
		set.add("a");
		set.add("b");
		set.add("c");
		set.forEach(System.out::println);//a  b  c 排序输出
	}
	public static void test2() {
		TreeSet<Emp> set = new TreeSet<>((emp1, emp2)-> emp1.getName().length() - emp2.getName().length());
		set.add(new Emp("admin", 12));
		set.add(new Emp("bff", 13));
		set.add(new Emp("abmin", 14));
		set.forEach(System.out::println);//Emp [name=bff, age=13]  Emp [name=admin, age=12]  排序输出

	}
	public static void main(String[] args) {
		//test1();
		test2();
	}

}

Map
HashMap 和 HashTable
HashMap是线程不安全的，HashTable是线程安全的
HashMap的键值对允许为null，而HashTable的键值对不允许为null

	public class Demo1 {
		
		//map的使用
		public static void test1() {
			Map<String, Object> map = new HashMap<>();
			//添加
			map.put("a", 1);
			map.put("b", 2);
			map.put("c", 3);
			//若key相同，则改变原来的value值
			map.put("a", 4);
			//删除
			map.remove("b");
			System.out.println(map.get("a"));
			//如果key不存在，返回null
			System.out.println(map.get("b"));
			System.out.println(map.get("c"));
			//判断指定key在不在map里
			System.out.println(map.containsKey("a"));
			//判断指定值在不在map里
			System.out.println(map.containsValue(1));
		}
		
		//遍历方法
		public static void test2() {
			Map<String, Object> map = new HashMap<>();
			map.put("a", 1);
			map.put("b", 2);
			map.put("c", 3);
			//第一种方式
			Set<String> keys = map.keySet();
			for(String key : keys) {
				System.out.println(key+":"+map.get(key));
			}
			System.out.println("============================================");
			//第二种方式
			Set<Entry<String, Object>> entrys = map.entrySet();
			for(Entry<String, Object> entry : entrys) {
				System.out.println(entry.getKey()+":"+entry.getValue());
			}
			System.out.println("============================================");
			//第三种方式
			map.forEach((k, v) -> System.out.println(k+":"+v));
		}
		
		public static void main(String[] args) {
			//test1();
			test2();
		}
	}

栈和队列
8.1 栈
先进后出
可以由数组实现，可以由链表实现

	public class Demo3 {
	
		public static void main(String[] args) {
			//Stack栈  数组实现
			Stack<String> stack = new Stack();
			stack.push("hello");//压栈
			System.out.println(stack.peek());//如果栈为空，抛出异常
			System.out.println(stack.peek());//返回栈顶的元素，栈顶元素不弹出来
			System.out.println(stack.pop());//返回栈顶的元素，栈顶元素弹出来，如果栈为空，抛出异常
			System.out.println(stack.peek());

			//栈 链表实现
			LinkedList<String> list = new LinkedList<>();
			list.push("zhou");
			System.out.println(list.peek());
		}
	
	}

8.2 队列
先进先出

	public class Demo4 {
	
		public static void main(String[] args) {
			// 队列
			LinkedList<String> list = new LinkedList<>();
			System.out.println(list.poll());//返回null
			list.offer("a");//入列
			list.offer("b");
			list.offer("c");
			System.out.println(list.peek());//返回队首的元素，并没有出列
			System.out.println(list.poll());//返回队首的元素，出列
			System.out.println(list);
			//Queue 队列
			Queue<String> queue = new LinkedList<>();
			
		}
	}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

Java基础之集合的相关文章

Eclipse 在源代码管理中保存操作

我们希望找到一种在签入之前执行代码标准的轻量级方法我们真的很喜欢使用 Eclipse 内置的想法保存操作 go to Preferences gt gt Java gt gt Editor gt gt Save Actions 其中有
Hibernate注解放置问题

我有一个我认为很简单的问题我见过两种方式的例子问题是为什么我不能将注释放在字段上让我举一个例子 Entity Table name widget public class Widget private Integer id Id G
插入最大日期（独立于数据库）

在我的本地设置中我使用一个简单的 H2 数据库托管解决方案将有另一个类似但不相同数据库我需要将最大可能日期插入到日期时间列中我尝试使用 Instant MAX 但是这会导致列中出现 169104626 12 11 20 08
是什么决定了从 lambda 创建哪个函数式接口？

请考虑这个例子 import java util function Consumer public class Example public static void main String args Example example new
OSGi：如果不取消服务会发生什么

这是我获取 OSGi 服务的方式 ServiceReference reference bundleContext getServiceReference Foo class getName Foo foo Foo bundleContex
比较两个文本文件的最快方法是什么，不将移动的行视为不同

我有两个文件非常大每个文件有 50000 行我需要比较这两个文件并识别更改然而问题是如果一条线出现在不同的位置它不应该显示为不同的例如考虑这个文件A txt xxxxx yyyyy zzzzz 文件B txt zzzzz xx
JAVA - Xuggler - 组合 MP3 音频文件和 MP4 电影时播放视频

使用 JAVA 和 Xuggler 以下代码组合 MP3 音频文件和 MP4 电影文件并输出组合的 mp4 文件我希望在合并音频和视频文件时应自动播放输出视频文件 String inputVideoFilePath in mp4 Stri
Cassandra java驱动程序协议版本和连接限制不匹配

我使用的java驱动程序版本 2 1 4卡桑德拉版本 dsc cassandra 2 1 10cql 的输出给出以下内容 cqlsh 5 0 1 Cassandra 2 1 10 CQL spec 3 2 1 Native protocol
如何安全地解决这个 Java 上下文类加载器问题？

我的数百名用户中只有一位在启动我的 Java 桌面应用程序时遇到问题他只有大约三分之一的时间开始另外三分之二的时间在启动时抛出 NullPointerException Exception in thread AWT EventQueu
使用 AES SecretKey 的 Java KeyStore setEntry()

我目前正在 Java 中开发一个密钥处理类特别是使用 KeyStore 我正在尝试使用 AES 实例生成 SecretKey 然后使用 setEntry 方法将其放入 KeyStore 中我已经包含了代码的相关部分 The KS Obj
Java 文件上传速度非常慢

我构建了一个小型服务它从 Android 设备接收图像并将其保存到 Amazon S3 存储桶中代码非常简单但是速度非常慢事情是这样的 public synchronized static Response postCommentP
画透明圆，外面填充

我有一个地图视图我想在其上画一个圆圈以聚焦于给定区域但我希望圆圈倒转也就是说圆的内部不是被填充而是透明的其他所有部分都被填充请参阅这张图片了解我的意思 http i imgur com zxIMZ png 上半部分显示了我可以
Java 8 流 - 合并共享相同 ID 的对象集合

我有一系列发票 class Invoice int month BigDecimal amount 我想合并这些发票这样我每个月都会收到一张发票金额是本月发票金额的总和例如 invoice 1 month 1 amount 1000
以编程方式在java的resources/source文件夹中创建文件？

我有两个资源文件夹 src 这是我的 java 文件资源这是我的资源文件图像 properties 组织在文件夹包中有没有办法以编程方式在该资源文件夹中添加另一个 properties 文件我尝试过这样的事情 public s
如何在 Java 中测试一个类是否正确实现了 Serialized（不仅仅是 Serialized 的实例）

我正在实现一个可序列化的类因此它是一个与 RMI 一起使用的值对象但我需要测试一下有没有办法轻松做到这一点澄清我正在实现该类因此在类定义中添加 Serialized 很简单我需要手动序列化反序列化它以查看它是否有效我找到了
Netty：阻止调用以获取连接的服务器通道？

呼吁ServerBootstrap bind 返回一个Channel但这不是在Connected状态因此不能用于写入客户端 Netty 文档中的所有示例都显示写入Channel从它的ChannelHandler的事件如channelCon
Cucumber Java 与 Spring Boot 集成 - Spring @Autowired 抛出 NullPointer 异常

我正在为 Spring boot 应用程序编写 cucumber java 单元测试来测试每个功能当我与 Spring Boot 集成时 Autowired 类抛出 NullPointer 异常 Spring Boot应用程序类 Spri
hashcode 的默认实现为以相同方式构造的对象返回不同的值

我在这里编写一个示例代码 public class Test private int i private int j public Test TODO Auto generated constructor stub public Test
调整添加的绘制组件的大小和奇怪的摆动行为

这个问题困扰了我好几天我正在制作一个特殊的绘画程序我制作了一个 JPanel 并添加了使用 Paint 方法绘制的自定义 jComponent 问题是每当我调整窗口大小时所有添加的组件都会消失或者只是不绘制因此我最终会得到一个
在 RESTful Web 服务中实现注销

我正在开发一个需要注销服务的移动应用程序登录服务是通过数据库验证来完成的现在我陷入了注销状态退一步您没有提供有关如何在应用程序中执行身份验证的详细信息并且很难猜测您在做什么但是需要注意的是在 REST 应用程序中不能有会话

随机推荐

core audio采集音频

涉及的接口有 IMMDeviceEnumerator IMMDevice IAudioClient IAudioCaptureClient 主要过程创建多媒体设备枚举器 IMMDeviceEnumerator 通过多媒体设备枚举器获取声卡
如何设计一个电商平台积分兑换系统？

目录 1 拉开差距的一类面试题 2 业务需求描述 3 对业务流程的思考 4 物流配送进度查询考虑到了吗 5 事务的保证 6 消息中间件的引入 7 重试机制的引入 8 引入幂等性机制 9 对这类面试题的总结 1 拉开差距的一类面试题现在面
idea安装findBugs 报idea运行项目报错Cannot run program

装了findbugs之后报错 Malformed argument has embedded quote Djava endorsed dirs 打开帮助编辑自定义VM选项在最后一列添加下列代码 Djdk lang Process al
long（Long）与int（Integer）之间的转换

1 将long型转化为int型这里的long型是基础类型 long a 10 int b int a 2 将Long型转换为int 型的这里的Long型是包装类型 Long a 10 int b a intValue 3 将Long型转
面试题：HashMap高频面试题

面试题 HashMap 1 底层数据结构 1 7和1 8有什么区别 1 7是数组链表 1 8是数组链表红黑树链表元素多时转换成红黑树元素少时转换成链表 2 为何要用红黑树为何一上来不树化树化阈值为何是8 何时会树化何时会退化
DB2客户端连接不上db2默认端口50000

DB2客户端连接不上db2默认端口50000 1 添加组和用户 root localhost expc groupadd g 2000 upp root localhost expc useradd m g upp d home upp u
Java中map的分类和常见的情况

Java为数据结构中定义了一个接口Java util Map 它有四个实现类分别是HashMap Hash table LinkedHashMap 和 TreeMap Map主要用于存储键值对根据键得到值因此不允许键重复重复了覆盖了
RabbitMQ（一）——入门

前言原来公司项目的消息中间件一直在用RabbitMQ 今天抽出时间简单总结梳理一下关于RabbitMQ的相关知识点我们知道消息队列在分布式系统中应用的的地方有很多它也有很多种类型除了今天重点介绍的RabbitMQ 还有像Active
ADC的接地

by Walt KesterQ I ve read your data sheets and application notes and also attendedyour seminars but I m still confused a
SpringBoot自动装配出现NULL的情况

环境 idea 2021 6 mysql 8 0 问题描述今天遇到通过 Autowired注解自动注入后发现字段为空的问题问题产生的原因是将被注入的对象交给了IOC容器管理但是却通过new对象的方式使用该对象导致该对象下的内容都无法
C语言if语句实现分支结构应用练习题

此练习为本人自己练习完成的答案答案方法不止一种仅供参考练习题列表 1 1 计算分段函数 1 10 分 1 2 分段函数 10 分 1 3 打折促销 10 分 1 4 12 24小时制 10 分 1 5 分数等级转换 10 分 1 1
HashMap源码

数组数组存储区间是连续的占用内存严重故空间复杂度很大但数组的二分查找时间复杂度很小为 o 1 数组的特点查找速度快插入和删除效率低链表链表存储区间离散占用内存比较宽松故空间复杂度很小但时间复杂度很大为 o n 链表
MTCNN+CRNN解决车牌识别问题-2

这次到CRNN部分了 CRNN网络很简单就是CNN RNN 因为RNN适用于时间序列类型的数据车牌呢其实也是有规律的比如第一位是汉字后面是字母汉字前一部分通过MTCNN将车牌区域已经定位了那这部分就需要拿CRNN来对其进行训
Unable to cast object of type in System.DirectoryServices.AccountManagement.GroupPrincipal

在使用UserPrincipal Current ToString 获取域登录用户信息时本地调试没有问题上传到服务器报错 Unable to cast object of type System DirectoryServices Ac
CSwin-PNet: CNN-Swin-Vit 组合金字塔网络用于超声图像中乳腺病变分割

ATTransUNet 期刊分析摘要贡献方法整体框架 1 Residual Swin Transformer block 2 Interactive channel attention module 3 Supplementary
java数据类型

整数类型 byte short int long 浮点数类型 float double 字符类型 String 布尔类型 boolean 1 整数类型 byte 128 127 short 32768 32767 int 214748364
CTFHub-时间盲注-wp #(自制脚本做法)

时间盲注脚本 coding utf 8 Time 2021 5 16 19 29 Author z1moq File ctfhub时间盲注 py Software PyCharm import requests import string
MATLAB实现控制系统模型（传递函数）的建立与转化，传递函数模型与零极点增益模型的转化，连续系统与离散系统的转化，对比不同采样周期对系统性能的影响

最近使用MATLAB做了很多控制工程方面的仿真测试不同系统的响应和特性不得不说使用MATLAB做控制仿真还是十分简洁方便的尤其是其中的simulink模块可以提供更加直观的模型方便分析与测试今天就分享在matlab中构造传递函数模
【微信小程序】微信支付接入全流程

一前置条件接入支付首先得需要有企业资质并开通企业对公户注册微信支付并进行对公户打款认证二开始接入 1 下载微信支付的AP证书 2 服务端接入微信支付 2 1 引入相关maven配置
Java基础之集合

Java基础集合 1 Collection接口 Collection 是 List 和 Set 的父接口常用方法如下 package com java day16 import java util ArrayList import ja

Java基础之集合

Java基础

集合

Java基础之集合 的相关文章

随机推荐

热门标签

Java基础之集合的相关文章