概念及实例见一下代码
1.Collection基础相关：
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.junit.Test;
/*
* 1.存储对象可以考虑：①数组 ②集合
* 2.数组存储对象的特点：Student[] stu = new Student[20]; stu[0] = new Student();...
* >弊端：①一旦创建，其长度不可变；②真实的数组存放的对象个数不可知。
* 3.集合
* Collection接口:方法：①add(Object obj),addAll(Collection coll),size(),clear(),isEmpty();
* ②remove(Object obj),removeAll(Collection coll),retainAll(Collection coll),
* equals(Object obj),contain(Object obj),containAll(Collection coll),hashCode();
* ③iterator(),toArray();
* ------List接口：存储有序的，可以重复的元素（"动态"数组）--新增的方法：删除remove(int index) 修改set(int index,Object obj)
* 获取get(init index) 插入add(int index,Object obj)
* 添加进List集合中的元素（或对象）所在的类一定要重写equals()方法
* ------ArrayList(主要的实现类)、LinkedList(对于频繁的插入、删除操作)、Vector(古老的实现类、线程安全的、效率低)
* ------Set接口：存储无序的，不可重复的元素（类似高中的"集合"）
* ------HashSet、LinkedHashSet、TreeSet
*
* Map接口:存储"键-值"对的数据(函数y=f(x))
* key不可重复，使用set存放，value可以重复，使用Collection来存放。
* 一个key-value对构成一个entry(Map.Entry),entry使用set存放
* ------HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)
*/
public class TestCollection {
@Test
public void testCollection2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
//6.contains(Object obj):判断集合中是否包含指定的obj元素，包含返回true，反之false
//判断依据：根据元素所在的类的equals()方法进行判断
//明确：如果存入集合中的元素是自定义的对象。要求：自定义类要求重写equals()方法
boolean b1 = coll.contains(123);
System.out.println(b1);
//7.containsAll(Collection coll):判断当前集合中是否包含coll中所有元素
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add(new String("aa"));
boolean b2 = coll.containsAll(coll1);
System.out.println(b2);
// coll1.add(456);
//8.retainAll(Collection coll):求当前集合与coll的共有元素，返回给当前元素
// coll.retainAll(coll1);
// System.out.println(coll);
//9.remove(Object obj):删除集合中的obj元素。若删除成功返回true反之false
boolean b3 = coll.remove("cc");
System.out.println(b3);
//10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素
coll.removeAll(coll1);
System.out.println(coll);
//11.equals(Object obj):判断两个集合元素是否完全一样
System.out.println(coll.equals(coll1));
//12.hashCode():
System.out.println(coll.hashCode());
System.out.println();
//13.toArray():将集合转成数组
Object[] obj = coll.toArray();
for(int i = 0;i < obj.length;i++){
System.out.println(obj[i]);
}
System.out.println();
//集合遍历
//14.iterator():返回一个Iterator接口实现类的对象
Iterator iterator = coll.iterator();
//方式一：不用
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//方式二：不用
// for(int i = 0;i< coll.size();i++){
// System.out.println(iterator.next());
// }
//方式三：使用
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void testCollection1(){
Collection coll = new ArrayList();
//1.size():返回集合中元素的个数
System.out.println(coll.size());
//2.add(Object obj):向集合中添加一个元素
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
System.out.println(coll.size());
//3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中
Collection coll1 = Arrays.asList(1,2,3);
coll.addAll(coll1);
System.out.println(coll.size());
//查看集合元素
System.out.println(coll);
//4.isEmpty():判断集合是否为空
System.out.println(coll.isEmpty());
//5.clear():清空集合元素
coll.clear();
System.out.println(coll.isEmpty());
}
}
2.Iterator遍历以及增强For循环
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.junit.Test;
public class TestIterator {
//使用增强for循环实现数组的遍历,注意数组没有迭代器
@Test
public void testFor1(){
String[] str = new String[]{"ss","dd","ff"};
for(String i:str){
System.out.println(i);
}
}
//使用增强for循环实现集合的遍历
@Test
public void testFor(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
for(Object i:coll){
System.out.println(i);
}
}
//错误写法
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
Iterator i = coll.iterator();
while((i.next()) != null){
System.out.println(i.next());
}
}
//正确写法:使用迭代器Iterator实现集合的遍历
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
//iterator():返回一个Iterator接口实现类的对象
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
3.List相关
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class TestList {
//ArrayList:List的主要实现类
/*
* List中相对于Collection新增加的方法
* void add(int index, Object ele):在指定的索引位置index添加元素ele
boolean addAll(int index, Collection eles)
Object get(int index):获取指定索引的元素
Object remove(int index):删除指定索引位置的元素
Object set(int index, Object ele):设置指定（修改）索引位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置,没有返回-1
int lastIndexOf(Object obj):返回obj在集合中最后一次出现的位置,没有返回-1
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list
List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index, Object ele))
查(get(int index)) 插(add(int index, Object ele)) 长度(size())
*/
@Test
public void testList2(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("aa"));
list.add(new String("ss"));
list.add(456);
System.out.println(list.indexOf(456));//1
System.out.println(list.lastIndexOf(456));//4
System.out.println(list.indexOf(123) == list.lastIndexOf(123));//true
System.out.println(list.indexOf(444));//-1
List list1 = list.subList(0, 3);//左闭右开
System.out.println(list1);
}
@Test
public void testList1(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("aa"));
list.add(new String("ss"));
System.out.println(list);
list.add(0, 111);
System.out.println(list);
Object obj = list.get(1);
System.out.println(obj);
list.remove(0);
System.out.println(list.get(0));
list.set(0, 222);
System.out.println(list.get(0));
}
}
4.Set相关
先建Person、Customer两个类，set和map要用
Person类
package com.atguigu.java_collection;
public class Person implements Comparable{
private String name;
private Integer age;
public Person() {
super();
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//当向TreeSet中添加Person类的对象时，依据此方法确定按照哪个属性排序
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person p = (Person)o;
return this.name.compareTo(p.name);
}
return 0;
}
}
Customer类：
package com.atguigu.java_collection;
public class Customer {
private String name;
private Integer id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Customer(String name, Integer id) {
super();
this.name = name;
this.id = id;
}
public Customer() {
super();
}
@Override
public String toString() {
return "Customer [name=" + name + ", id=" + id + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Customer other = (Customer) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
Set相关
package com.atguigu.java_collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Test;
/*
* Collection接口：
* ------List接口：存储有序的，可以重复的元素
* ------ArrayList(主要的实现类)
* ------LinkedList(对于频繁的插入、删除操作)
* ------Vector(古老的实现类、线程安全的、效率低)
* ------Set接口：存储无序的，不可重复的元素。Set中常用的方法都是Collection中定义的
* ------HashSet(主要实现类)
* ------LinkedHashSet
* ------TreeSet
*/
public class TestSet {
@Test
public void testTreeSet3() {
TreeSet set = new TreeSet(new Comparator() {
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
});
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1002));
set.add(new Customer("GG", 1004));
set.add(new Customer("CC", 1001));
set.add(new Customer("DD", 1001));
for (Object str : set) {
System.out.println(str);
}
}
/*
* TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！
*/
@Test
public void testTreeSet2() {
// 1.创建一个实现了Comparator接口的类对象
Comparator com = new Comparator() {
// 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer
// 的哪个属性排序的。
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
// 2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1002));
set.add(new Customer("GG", 1004));
set.add(new Customer("CC", 1001));
set.add(new Customer("DD", 1001));
for (Object str : set) {
System.out.println(str);
}
}
/*
* TreeSet:
* 1.向TreeSet中添加的元素必须是同一个类的。
* 2.可以按照添加进集合中的元素的指定的顺序遍历。
* 如String、包装类等默认按照从小到大的顺序遍历。
* 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
* 4.自然排序：要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法
* 在此方法中，指明按照自定义类的哪个属性进行排序。
*
* 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此
* 属性值相同，但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
*
* >compareTo()与hashCode()以及equals()三者保持一致！
*/
@Test
public void testTreeSet1(){
Set set = new TreeSet();
// set.add("aa");
// set.add("ss");
// set.add("ff");
// set.add("kk");
// 当Person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
set.add(new Person("cc",22));
set.add(new Person("ff",23));
set.add(new Person("aa",25));
for(Object str:set){
System.out.println(str);
}
}
/*
* LinkedHashSet:使用链表维护了一个添加进集合中的顺序，导致当遍历LinkedHashSet集合
* 元素时，是按照添加进去顺序遍历的！
*
* LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
*
*/
@Test
public void testLinkedHashSet(){
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add("aa");
set.add("ss");
set.add(null);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
/*
* Set:存储的元素是无序的，不可重复的！
* 1.无序性：无序性!=随机性。真正的无序性指的是元素在底层存储的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()犯法
* 进而保证Set中元素的不可重复性！
*
* Set中的元素是如何存储的？--使用哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，
* 此哈希值决定了此对象在Set中存储位置。若此位置之前没有对象存储，则这个对象直接存储
* 在此位置。若此位置已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，
* 后一个对象就不能再添加进来。
* 万一返回false，都存储（不建议如此）
* >要求：hashCode()方法要与equals()方法一致。
*/
@Test
public void testHashSet(){
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("aa");
//set.add("aa");
set.add("ss");
set.add(null);
Person p1 = new Person("gg", 25);
Person p2 = new Person("gg", 25);
set.add(p1);
set.add(p2);
System.out.println(set.size());
System.out.println(set);
}
}
5.Map相关
package com.atguigu.java_collection;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import org.junit.Test;
/*
* Collection接口
*
* Map接口：存储"键-值"对的数据(函数y=f(x))
* key不可重复，使用set存放，value可以重复，使用Collection来存放。
* 一个key-value对构成一个entry(Map.Entry),entry使用set存放
* |-----HashMap:Map的主要实现类
* |-----LinkedHashMap:使用链表维护添加进Map中的顺序。故遍历Map时，是按添加的顺序遍历的。
* |-----TreeMap:按照添加进Map中的元素的key的指定属性进行排序。要求：key必须是同一个类的对象！
* 针对key：自然排序 vs 定制排序
* |-----Hashtable:古老的实现类，线程安全，不建议使用。
* |----Properties:常用来处理属性文件。键和值都为String类型的
*/
public class TestMap {
//使用Properties处理属性文件
@Test
public void test6() throws FileNotFoundException, IOException{
Properties pros = new Properties();
pros.load(new FileInputStream(new File("jdbc.properties")));
String user = pros.getProperty("user");
System.out.println(user);
String password = pros.getProperty("password");
System.out.println(password);
}
// 定制排序
@Test
public void test5() {
Comparator com = new Comparator() {
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
TreeMap map = new TreeMap(com);
map.put(new Customer("AA", 1001), 87);
map.put(new Customer("CC", 1001), 67);
map.put(new Customer("MM", 1004), 77);
map.put(new Customer("GG", 1002), 97);
Set set1 = map.keySet();
for (Object obj : set1) {
System.out.println(obj + "----->" + map.get(obj));
}
}
// 自然排序
@Test
public void test4(){
Map map = new TreeMap();
map.put(new Person("AA", 23), 89);
map.put(new Person("MM", 22), 79);
map.put(new Person("GG", 23), 99);
map.put(new Person("JJ", 13), 69);
Set set = map.keySet();
for(Object obj:set){
System.out.println(obj + "----->" + map.get(obj));
}
}
@Test
public void test3() {
Map map = new LinkedHashMap();
map.put("AA", 213);
map.put("BB", 45);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD", 23), 89);
Set set1 = map.keySet();
for (Object obj : set1) {
System.out.println(obj + "----->" + map.get(obj));
}
}
/*
* 如何遍历Map
* Set keySet()
* Collection values()
* Set entrySet()
*/
@Test
public void test2(){
Map map = new HashMap();
map.put("AA", 123);
map.put("BB", 456);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD",22), 656);
//1.遍历key集
Set set = map.keySet();
for(Object obj:set){
System.out.println(obj);
}
//2.遍历values集
Collection values = map.values();
Iterator i = values.iterator();
while(i.hasNext()){
System.out.println(i.next());
}
//3.如何遍历key-value对
//方式一：
Set set1 = map.keySet();
for(Object obj:set1){
System.out.println(obj + "---->" + map.get(obj));
}
//方式二：
Set set2 = map.entrySet();
for(Object obj:set2){
Map.Entry entry = (Map.Entry)obj;
//System.out.println(entry.getKey() + "---->" +entry.getValue());
System.out.println(entry);
}
}
/*
* Object put(Object key,Object value):向Map中添加一个元素
* Object remove(Object key):按照指定的key删除此key-value
* void putAll(Map t)
* void clear():清空 Object
* get(Object key)：获取指定key的value值。若无此key，则返回null
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* int size():返回集合的长度
* boolean isEmpty()
* boolean equals(Object obj)
*
* HashMap： 1.key是用Set来存放的，不可重复。value是用Collection来存放的，可重复
* 一个key-value对，是一个Entry。所有的Entry是用Set存放的，也是不可重复的。
* 2.向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同 则只能添加进后添加的那个元素。
*/
@Test
public void test1(){
Map map = new HashMap();
map.put("AA", 123);
map.put("BB", 456);
map.put("BB", 45);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD",22), 656);
map.put(new Person("DD",22), 565);
System.out.println(map.size());
System.out.println(map);
map.remove("BB");
System.out.println(map);
}
}
6.Collections:操作Collection和Map的工具类
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
/*
* 操作Collection以及Map的工具类：Collections
*/
public class TestCollections {
/*
* Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
*/
@Test
public void testCollections2(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(12);
list.add(78);
list.add(456);
Object obj = Collections.max(list);
System.out.println(obj);
int count = Collections.frequency(list, 456);
System.out.println(count);
//实现List的复制
//List list1 = new ArrayList();//错误的实现方式
List list1 = Arrays.asList(new Object[list.size()]);
Collections.copy(list1, list);
System.out.println(list1);
//通过如下的方法保证list的线程安全性。
List list2 = Collections.synchronizedList(list);
System.out.println(list2);
}
/*
* reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
*/
@Test
public void testCollections1(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(12);
list.add(78);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.swap(list, 0, 1);
System.out.println(list);
}
}
相关推荐
《永磁无刷直流电机控制系统与软件综合研究——集成电机计算软件、电机控制器及电磁设计软件的创新设计与实践》,永磁无刷直流电机计算与控制软件：高效电机控制器与电磁设计工具,永磁无刷直流电机计算软件，电机控制器，无刷电机设计软件,电机电磁设计软件 ,永磁无刷直流电机计算软件; 电机控制器; 无刷电机设计软件; 电机电磁设计软件,无刷电机设计专家：永磁无刷直流电机计算与控制器设计软件
新能源汽车VCU开发模型及策略详解：从控制策略到软件设计全面解析,新能源汽车VCU开发模型及策略详解：从控制策略到软件设计全面解析,新能源汽车VCU开发模型及控制策略，MBD电控开发 新能源汽车大势所向，紧缺VCU电控开发工程师，特别是涉及新能源三电系统，工资仅仅低于无人驾驶、智能驾驶岗位。 ——含控制策略模型 整车控制策略详细文档 通讯协议文档 接口定义 软件设计说明文档 等（超详细，看懂VCU电控策略开发就通了） 内容如下： 新能源汽车整车控制器VCU学习模型，适用于初学者。 1、模型包含高压上下电，行驶模式管理，能量回馈，充电模式管理，附件管理，远程控制，诊断辅助功能。 2、软件说明书（控制策略说明书） 3、模型有部分中文注释 对想着手或刚开始学习整车控制器自动代码生成或刚接触整车控制器有很大帮助。 ,新能源汽车VCU开发模型; 控制策略; MBD电控开发; 模型学习; 代码生成; 整车控制器; 能量回馈; 诊断辅助功能,新能源汽车电控开发详解：VCU控制策略模型及学习手册
内容概要：本文详细介绍了两种利用 Python 读取 Excel 文件的不同方法，分别是基于 pandas 和 openpyxl。对于想要利用Python 处理 Excel 数据的读者来说，文中不仅提供了简洁明了的具体代码片段以及执行效果展示，还针对每个库的应用特性进行了深度解析。此外，文档提到了一些进阶应用技巧如只读特定的工作薄、过滤某些列等，同时强调了需要注意的地方（像是路径设置、engine 参数调整之类），让读者可以在面对实际项目需求时做出更加明智的选择和技术选型。 适合人群：对 Python 有基本掌握并希望提升数据读取能力的开发人员。 使用场景及目标：适用于任何涉及到批量数据导入或是与 Excel 进行交互的业务流程。无论是做初步的数据探索还是深入挖掘隐藏于电子表格背后的故事，亦或是仅为了简化日常办公自动化任务都可以从中受益。最终目标帮助使用者熟悉两大主流 Excel 解决方案的技术特性和最佳实践。 阅读建议：本文既是一份详尽的学习指南也是一份方便随时查阅的手册。因此初学者应当认真研究所提供的示例，而有一定经验者也可以快速定位到感兴趣的部分查看关键要点。
# 医护人员排班系统 ## 1. 项目介绍 本系统是一个基于SpringBoot框架开发的医护人员排班管理系统,用于医院管理医护人员的排班、调班等工作。系统提供了完整的排班管理功能,包括科室管理、人员管理、排班规则配置、自动排班等功能。 ## 2. 系统功能模块 ### 2.1 基础信息管理 - 科室信息管理:维护医院各科室基本信息 - 医护人员管理:管理医生、护士等医护人员信息 - 排班类型管理:配置不同的排班类型(如:早班、中班、晚班等) ### 2.2 排班管理 - 排班规则配置:设置各科室排班规则 - 自动排班:根据规则自动生成排班计划 - 排班调整:手动调整排班计划 - 排班查询:查看各科室排班情况 ### 2.3 系统管理 - 用户管理:管理系统用户 - 角色权限:配置不同角色的操作权限 - 系统设置:管理系统基础配置 ## 3. 技术架构 ### 3.1 开发环境 - JDK 1.8 - Maven 3.6 - MySQL 5.7 - SpringBoot 2.2.2 ### 3.2 技术栈 - 后端框架:SpringBoot - 持久层:MyBatis-Plus - 数据库:MySQL - 前端框架:Vue.js - 权限管理:Spring Security ## 4. 数据库设计 主要数据表: - 科室信息表(keshixinxi) - 医护人员表(yihurengyuan) - 排班类型表(paibanleixing) - 排班信息表(paibanxinxi) - 用户表(user) ## 5. 部署说明 ### 5.1 环境要求 - JDK 1.8+ - MySQL 5.7+ - Maven 3.6+ ### 5.2 部署步骤 1. 创建数据库并导入SQL脚本 2. 修改application.yml中的数据库配置 3. 执行maven打包命令:mvn clean package 4. 运行jar包:java -jar xxx.jar ## 6. 使用说明 ### 6.1 系统登录 - 管理员账号:admin - 初始密码:admin ### 6.2 基本操作流程 1. 维护基础信息(科室、人员等) 2. 配置排班规则 3. 生成排班计划 4. 查看和调整排班 ## 7. 注意事项 1. 首次使用请及时修改管理员密码 2. 定期备份数据库 3. 建议定期检查和优化排班规则
MATLAB仿真的夫琅禾费衍射强度图：圆孔、圆环、矩形孔定制研究,MATLAB仿真：夫琅禾费衍射强度图的可定制性——以圆孔、圆环及矩形孔为例的研究分析,MATLAB夫琅禾费衍射强度图仿真 圆孔，圆环，矩形孔可定制。 ,MATLAB; 夫琅禾费衍射; 强度图仿真; 圆孔; 圆环; 矩形孔; 可定制。,MATLAB仿真夫琅禾费衍射强度图：定制孔型（圆孔/圆环/矩形）
详细介绍及样例数据：https://blog.csdn.net/samLi0620/article/details/145652300
基于Dugoff轮胎模型与B08_01基础建模的七自由度车辆动力学模型验证：利用MATLAB 2018及以上版本与CarSim 2020.0软件的仿真对比研究,基于Dugoff轮胎模型与B08_01框架的七自由度车辆动力学模型验证——使用MATLAB 2018及以上版本与CarSim 2020.0软件进行仿真对比研究,七自由度车辆动力学模型验证（Dugoff轮胎模型，B08_01基础上建模） 1.软件: MATLAB 2018以上；CarSim 2020.0 2.介绍: 基于Dugoff轮胎模型和车身动力学公式，搭建7DOF车辆动力学Simulink模型，对相关变量（质心侧偏角，横摆角速度，纵、横向速度及加速度）进行CarSim对比验证。 ,核心关键词：七自由度车辆动力学模型验证; Dugoff轮胎模型; B08_01建模基础; MATLAB 2018以上; CarSim 2020.0; Simulink模型; 变量对比验证。,基于Dugoff轮胎模型的七自由度车辆动力学模型验证与CarSim对比
【毕业设计】基于Java+servlet+jsp+css+js+mysql实现“转赚”二手交易平台_pgj
微猫恋爱聊妹术小程序源码介绍： 微猫恋爱聊妹术小程序源码是一款全新升级的聊天工具，它采用全新主题和UI，完美支持分享朋友圈功能。同时，它的独立后台也进行了大规模更新，让操作更加简单。其中，课堂页面、搜索页面和子话术列表页面等，均增加了流量主展示，具有超多的功能。 安装教程： 您可以先加入微猫恋爱聊妹术小程序源码的赞助群，然后在群内找到魔方安装说明。根据源码编号找到相应的安装说明，非常详细，让您轻松完成安装。
电气安装工程安全技术规程_蒋凯，杨华甫，马仲范，王清禄译；孙照森校；鞍钢工程技术编委会编
基于Copula函数的风光空间相关性联合场景生成与K-means聚类削减MATLAB研究,基于Copula函数的风光空间相关性联合场景生成与K-means聚类削减算法研究,基于copula的风光联合场景生成?K-means聚类并削减 MATLAB 由于目前大多数研究的是不计风光出力之间的相关性影响，但是地理位置相近的风电机组和光伏机组具有极大的相关性。 因此，采用 Copula 函数作为风电、光伏联合概率分布，生成风、光考虑空间相关性联合出力场景，在此基础上，基于Kmeans算法，分别对风光场景进行聚类，从而实现大规模场景的削减，削减到5个场景，最后得出每个场景的概率与每个对应场景相乘求和得到不确定性出力 ,基于Copula的风光联合场景生成; K-means聚类削减; 空间相关性; 概率分布; 场景削减,基于Copula与K-means的风光联合场景生成与削减研究
模块化多电平变流器MMC的VSG控制技术研究：基于MATLAB-Simulink的仿真分析与定制实现——支持三相与任意电平数,构网型模块化多电平变流器MMC的VSG控制策略与仿真模型：三相负荷变动下的虚拟同步发电机控制研究,构网型 模块化多电平变流器 MMC 的VSG控制 同步发电机控制 MATLAB–Simulink仿真模型，可按需求定制 10电平.14电平，任意电平可做。 三相MMC，采用VSG控制。 设置负荷变动，调整有功无功，保持电网电压和频率 ,构网型模块化多电平变流器; MMC的VSG控制; 虚拟同步发电机控制; MATLAB–Simulink仿真模型; 任意电平可做; 三相MMC; 负荷变动; 有功无功调整; 电网电压和频率保持。,基于VSG控制的模块化多电平变流器(MMC)的构网型仿真模型
暗通道算法DCP-Python实现
南师大实验室安全准入知识供学习
纯openMV寻迹小车.zip
【毕业设计】基于Java mvc架构开发的完整购物网站
以下是针对初学者的 **51单片机入门教程**，内容涵盖基础概念、开发环境搭建、编程实践及常见应用示例，帮助你快速上手。
springboot医院信管系统--
springboot私人健身与教练预约管理系统--
yolov8-0的资源