java oop 集合框架
集合主要是用来存放数据的,集合与数组的主要区别在于,集合的大小不受限制,而数组的大小受限制,在使用集合增加数据时又常常与泛型联系起来,所以集合和泛型在实际开发过程中总会结合在一起
数组致命的缺点是数组大小一旦确定,其大小将不在改变,集合可以认为是一种可变的数组,大小可以随着元素的增加而增加。
集合与数组具体的区别:
1.数组是一个线性序列,所以可以快速访问其他元素,当用户创建了一个数组时,其容量是不变的,而且在生命周期也是不能改变的,还有java数组会做边界检查,如果发现有越界现象,会报RuntimeException错误,所以不用担心和CC++一样不做边界检查而出现的问题
2.集合容量是可变的,扩展性比较好
3.集合的内部实现基于数组,所以数组的效率要高于集合
集合两大类:collection集合与map集合
List 结构集合类:
ArrayList类 LinkedList类 Vector类 Stack 类
Map结构集合类: HashMap Hashtable
Set集合类:HashSet TreeSet TreeSet
Queue集合类:Queue接口
1.ArrayList
List集合的子接口,允许集合存储元素可以重复,并可以将null存储在集合中,ArrayList实例都有一个默认容量,该容量用来存储数组元素的大小,并且ArrayList集合的长度可以自动增长
ArrayList是线程不安全的,如果有多个线程同时访问ArrayList,有可能出现访问数据不一致现象,因此使用ArrayList要结合线程加以同步
eg:
1.向ArrayList集合加元素
import java.util.ArrayList;
import java.util.List;
public class text3 {
public static void main(String[] args) {
List lis=new ArrayList();
lis.add("张无忌");
lis.add("张无忌");
lis.add("张无忌");
lis.add(520);
System.out.println(lis);
}
}
增加泛型后;
import java.util.ArrayList;
import java.util.List; public class text3 {
public static void main(String[] args) {
List<String> lis = new ArrayList<String>();
//增加内容
lis.add("张无忌");
lis.add("张无忌");
lis.add("张无忌");
lis.add("张无忌");
lis.add("wangzhi");
System.out.println(lis);
}
}
2.LinkedList
ArrayList 只能在尾部增加而不能在头部增加,LinkedList可以在集合的前后增加,LinkedList是线程不安全的,如果有多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,有可能造成集合访问不同步的情况发生
LinkedList增加元素
import java.util.ArrayList;
import java.util.List;
import java.util.LinkedList;
public class text3 {
public static void main(String[] args) {
LinkedList<String> lis=new LinkedList<String>();
//增加元素
lis.add("张三");
lis.add("李四");
lis.addFirst("王五");
lis.addLast("赵六");
System.out.println(lis);
}
}
3.HarshSet
该类实现Set接口,并且HashSet的顺序是不确定的,该类允许加入null元素,不允许集合添加重复元素,如果添加重复元素,将会覆盖之前的元素。HashSet是线程不同步的,如果多个线程同时访问一个HashSet,而其中至少一个线程修改了该集合,则可能造成数据访问不一致的情况发生
import java.util.HashSet;
import java.util.Set;
public class text3 {
public static void main(String[] args) {
Set<String> set=new HashSet<String>();
//增加元素
set.add("zhangsan");
set.add("lisi");
set.add("wangwu");
set.add("wangwu");
System.out.println(set);
}
}
4.TreeSet
用来集合元素内部排序使用的,TreeSet 集合是线程不同步的,
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class text3 {
public static void main(String[] args) {
//创建HashSet
TreeSet ts = new TreeSet();
// Add elements to the tree set
ts.add("C");
ts.add("A");
ts.add("B");
ts.add("E");
ts.add("F");
ts.add("D");
ts.add("A");
System.out.println(ts); }
}
Comparable/comparable接口
主要用来对对象排序使用,这种排序称为自然排序,compareTo方法用户自己定义排序规则
int comparableTo(To) 比较次对象与指定对象的顺序,小于 等于 大于:负整数 0 正整数
实现Comparable接口的实体类:
Person
package text3; /**
* 为了更好的实现排序功能,建议比较排序的类实现hashCode和equals方法
*
* @author Administrator
*
*/
public class Person implements Comparable<Person> {
private String name;
private int age; public Person(String name, int age) {
this.name = name;
this.age = age;
} @Override
public int hashCode() {
final int prime = 31;//注意31
int result = 1;
result = prime * result + age;
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;
final Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false; return true;
} public String toString() {
return name + "," + age;
} @Override
public int compareTo(Person o) {
int c = age - o.age;
if (c != 0)
return c;
return name.compareTo(o.getName());
} // 自动调出
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;
}
}
Test
package text3;
import java.util.HashSet;
import java.util.Set; public class Text {
public static void main(String[] args) {
Set<Person> set=new HashSet<Person>();
set.add(new Person("张三丰",20));
set.add(new Person("张无忌",22));
set.add(new Person("刘德华",31));
set.add(new Person("王志",12));
System.out.println(set);
}
}
增强for循环主要是用来打印集合的,并且增强for循环只能打印数组和泛型的集合,没有增强for循环之前,也可以用for来打印集合
使用for打印
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet; public class Person{
public static void main(String[] args) {
printList();
System.out.println("-------------------------------------------");
printSet();
} private static void printSet() {
// TODO Auto-generated method stub
Set<String> set=new HashSet<String>();
set.add("张无忌");
set.add("张学友");
set.add("王志大帅哥");
Object[] s=set.toArray();
for(int i=0;i<s.length;i++)
System.out.println(s[i]);
} private static void printList() {
// TODO Auto-generated method stub
List<String> lis=new ArrayList<String>();
lis.add("张无忌");
lis.add("张学友");
lis.add("谢霆锋");
lis.add("张柏芝");
for(int i=0;i<lis.size();i++)
System.out.println(lis.get(i));
}
}
使用增强for循环
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet; public class Person{
public static void main(String[] args) {
printList();
System.out.println("-------------------------------------------");
printSet();
} private static void printSet() {
// TODO Auto-generated method stub
Set<String> set=new HashSet<String>();
set.add("张无忌");
set.add("张学友");
set.add("王志大帅哥");
for(String s:set){
System.out.println(s);
}
} private static void printList() {
// TODO Auto-generated method stub
List<String> lis=new ArrayList<String>();
lis.add("张无忌");
lis.add("张学友");
lis.add("谢霆锋");
lis.add("张柏芝");
for(String s:lis){
System.out.println(s);
}
}
}
使用增强for循环可以很方便的打印集合,但增强for循环的局限性在于它只能打印集合中的内容,不能对集合本身进行修改,修改后会出现意想不到的情况,会报错
import java.util.Set;
import java.util.List;
import java.util.ArrayList;
import java.util.HashSet; public class Person{
public static void main(String[] args) {
printList();
System.out.println("-------------------------------------------");
printSet();
} private static void printSet() {
// TODO Auto-generated method stub
Set<String> set=new HashSet<String>();
set.add("张无忌");
set.add("张学友");
set.add("王志大帅哥");
for(String s:set){
System.out.println(s);
}
} private static void printList() {
// TODO Auto-generated method stub
List<String> lis=new ArrayList<String>();
lis.add("张无忌");
lis.add("张学友");
lis.add("谢霆锋");
lis.add("张柏芝");
for(String s:lis){
System.out.println(s);
}
}
}
而使用普通for循环
package text4;
import java.util.List;
import java.util.ArrayList;
public class Hello {
public static void main(String[] args) {
delList();
}
public static void delList(){
//创建List实例化
List<String> lis=new ArrayList<String>();
//增加内容
lis.add("张无忌");
lis.add("张无忌");
lis.add("刘德华");
//删除
for(int i=0;i<lis.size();i++){
if("张无忌".equals(lis.get(i))){
lis.remove(i);
}
}
//打印
for(String s:lis) System.out.println(s);
} }
!!!有两个张无忌但是只删除了一个,解决方案
package text4;
import java.util.List;
import java.util.ArrayList;
public class Hello {
public static void main(String[] args) {
delList();
}
public static void delList(){
//创建List实例化
List<String> lis=new ArrayList<String>();
//增加内容
lis.add("张无忌");
lis.add("张无忌");
lis.add("刘德华");
//删除
for(int i=0;i<lis.size();i++){
if("张无忌".equals(lis.get(i))){
lis.remove(i);
i--;
}
}
//打印
for(String s:lis) System.out.println(s);
} }
Iterator接口:
使用Iterator遍历集合
package text4; import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.HashSet; public class Hello {
public static void main(String[] args) {
iteratorList();
System.out.println("--------------------------------");
iteratorSet(); } public static void iteratorList() {
// 创建实例化
List<String> lis = new ArrayList<String>();
lis.add("张无忌");
lis.add("张无忌");
lis.add("刘德华");
System.out.println("删除前");
System.out.println();
// 获得iterator接口
Iterator<String> it = lis.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
if ("张无忌".equals(s)) {
it.remove();
}
}
System.out.println();
System.out.println("删除后");
// 删除
for (String s : lis)
System.out.println(s);
} public static void iteratorSet() {
// HashSet实例化
Set<String> set = new HashSet<String>();
set.add("张无忌");
set.add("张无忌");
set.add("张三丰");
set.add("刘德华");
// 获得Iterator接口
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
Map接口
基于哈希表的Map接口的实现,Map可以存储键值,并允许使用null值和null键,Map接口不保证映射的顺序,Hashmap是线程不同步的,如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该印射,则它必须保持外部同步,主要用来存储 key_value数据
HashMap增加元素; 可重复当时会覆盖
package text4; import java.util.Map;
import java.util.HashMap; public class Hello {
public static void main(String[] args) {
add();
} public static void add() {
Map<String, String> map = new HashMap<String, String>();
// 增加元素
map.put("国家", "中国");
map.put("老公", "小明");
map.put("老婆", "小红");
map.put("身份证", "123456");
// 获取特定key对应的value
String id = map.get("身份证");
System.out.println(id);
}
}
取出map中的所有的key值
package text4; import java.util.Map;
import java.util.HashMap;
import java.util.Set;
//import java.util.keySet;
public class Hello {
public static void main(String[] args) {
add();
} public static void add() {
Map<String, String> map = new HashMap<String, String>();
// 增加元素
map.put("国家", "中国");
map.put("老公", "小明");
map.put("老婆", "小红");
map.put("身份证", "123456");
map.put("身份证", "421127199712241714");
// 获取特定key对应的value
String id = map.get("身份证");
System.out.println(id);
//取出所有的key值
Set<String> keys=map.keySet();
for(String s:keys){
System.out.println(s);
}
}
}
获取集合中所有的value值
package text4; import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
//import java.util.keySet;
public class Hello {
public static void main(String[] args) {
add();
} public static void add() {
Map<String, String> map = new HashMap<String, String>();
// 增加元素
map.put("国家", "中国");
map.put("老公", "小明");
map.put("老婆", "小红");
map.put("身份证", "123456");
map.put("身份证", "421127199712241714");
//取出所有的key值
Set<String> keys=map.keySet();
for(String s:keys){
System.out.println(s);
}
System.out.println("-----------------------------------");
//获取所有的value值
Collection<String> cs=map.values();
for(String s:cs) System.out.println(s); }
}
获取所有的key与value值
package text4; import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Collection;
//import java.util.keySet;
public class Hello {
public static void main(String[] args) {
add();
} public static void add() {
Map<String, String> map = new HashMap<String, String>();
// 增加元素
map.put("国家", "中国");
map.put("老公", "小明");
map.put("老婆", "小红");
map.put("身份证", "123456");
map.put("身份证", "421127199712241714");
System.out.println("获取所有的key值");
//取出所有的key值
Set<String> keys=map.keySet();
for(String s:keys){
System.out.println(s);
}
System.out.println("-----------------------------------");
System.out.println("获取所有的value值");
//获取所有的value值
Collection<String> cs=map.values();
for(String s:cs) System.out.println(s);
System.out.println("------------------------------------");
System.out.println("获取所有的value与key值");
//取出所有的value与key值
Set<Map.Entry<String, String>> sets=map.entrySet();
for(Map.Entry<String, String> s:sets){
String key=s.getKey();
String value=s.getValue();
System.out.println(key+":"+value);
}
}
}
容器选择原则;
综合案例:
A:职员管理系统:
package day4; import java.util.*;
import java.io.*;
/**
* @author qingfeng
* 重要思想:面向对象思想(添加员工管理类)
* 功能:公司职员薪水管理系统
*/
public class SalarySystem { public static void main(String[] args) throws IOException { ClerkManager cm = new ClerkManager();//创建员工管理类 InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr); while(true)
{
//简易菜单
System.out.println("公司职员薪水管理系统");
System.out.println("---------------------------------------");
System.out.println("1.添加新员工");
System.out.println("2.根据工号显示该员工的信息");
System.out.println("3.显示所有员工信息");
System.out.println("4.修改员工的薪水");
System.out.println("5.根据工号删除该员工的信息");
System.out.println("6.根据薪资由低到高排序");
System.out.println("7.统计员工的平均工资、最高工资和最低工资");
System.out.println("---------------------------------------");
System.out.println("请选择序号:"); String no = br.readLine(); if(no.equals("1")){
System.out.println("添加新员工:");
System.out.println("请输入姓名:");
String name = br.readLine(); System.out.println("请输入性别:");
String sex = br.readLine(); System.out.println("请输入年龄:");//如何用InputStreamReader来输入一个int型的数据
Scanner sc = new Scanner(System.in);
int age = sc.nextInt(); System.out.println("请输入工号:");
String clerkNo = br.readLine(); System.out.println("请输入薪资:");
float salary = Float.parseFloat(br.readLine()); Clerk clerk = new Clerk(name, sex, age, clerkNo, salary);//创建员工对象并且调用构造方法初始化
cm.addClerk(clerk);//调用“添加新员工”方法 }else if(no.equals("2")){
System.out.println("请输入员工号:");
String clerkNo = br.readLine();//接收输入的工号
cm.showInfo(clerkNo); }else if(no.equals("3")){
System.out.println("显示所有员工信息:");
cm.showAllInfo(); }else if(no.equals("4")){
System.out.println("修改员工的薪水:");
System.out.println("输入员工工号:");
String clerkNo = br.readLine();//接收输入的工号
System.out.println("修改员工薪资:");
String sal = br.readLine();
float salary = Float.parseFloat(sal);
cm.modifySal(clerkNo, salary); }else if(no.equals("5")){
System.out.println("根据工号删除该员工的信息:");
System.out.println("输入员工工号:");
String clerkNo = br.readLine();//接收输入的工号
cm.deleteInfo(clerkNo); }else if(no.equals("6")){
System.out.println("根据薪资由低到高排序");
cm.Qsort(0, cm.al.size()-1);
cm.showAllInfo();
}else if(no.equals("7")){
System.out.println("统计员工的平均工资、最高工资和最低工资:");
cm.calSalary();
}else if(no.equals("8")){
System.exit(0);
}else{
System.out.println("输入不合法!");
}
} }
}
//员工管理类(非常重要!面向对象)
class ClerkManager
{
//成员属性
ArrayList al = null; //构造方法:初始化 不断创造新对象
public ClerkManager()
{
al = new ArrayList();//注意写法!!
} //成员方法
//添加新员工!
public void addClerk(Clerk clerk) //注意用增加的对象的引用作为参数!
{
al.add(clerk); //ArrayList添加方法用add()方法!
} //根据工号显示该员工的信息
public void showInfo(String no)
{
int flag = 0;
for(int i=0; i<al.size(); i++)
{
Clerk clerk= (Clerk)al.get(i);
if(clerk.getNo().equals(no))
{
flag = 1;
System.out.println("clerk"+(i+1)+"的信息是:");
System.out.print("姓名:"+clerk.getName());
System.out.print(" 性别:"+clerk.getSex());
System.out.print(" 年龄:"+clerk.getAge());
System.out.print(" 工号:"+clerk.getNo());
System.out.println(" 薪资:"+clerk.getSalary());
}
}
if(flag == 0)
System.out.println("找不到所查工号!");
} //显示所有员工信息
public void showAllInfo()
{
for(int i=0; i<al.size(); i++)
{
Clerk clerk= (Clerk)al.get(i);
System.out.println("clerk"+(i+1)+"的信息是:"); System.out.print("姓名:"+clerk.getName());
System.out.print(" 性别:"+clerk.getSex());
System.out.print(" 年龄:"+clerk.getAge());
System.out.print(" 工号:"+clerk.getNo());
System.out.println(" 薪资:"+clerk.getSalary());
}
} //修改员工的薪水
public void modifySal(String no, float sal) //员工编号 最新的薪资
{
int flag = 0;
for(int i=0; i<al.size(); i++)
{
Clerk clerk= (Clerk)al.get(i);
if(clerk.getNo().equals(no))
{
flag = 1;
clerk.setSalary(sal);
}
}
if(flag == 0)
System.out.println("找不到所查工号!");
} //根据工号删除该员工的信息
public void deleteInfo(String no)
{
int flag = 0;
for(int i=0; i<al.size(); i++)
{
Clerk clerk= (Clerk)al.get(i);
if(clerk.getNo().equals(no))
{
flag = 1;
al.remove(i);
}
}
if(flag == 0)
System.out.println("找不到所查工号!");
} //根据薪资由低到高排序
public void Qsort(int left, int right)
{
int i = left;
int j = right; if(i < j)//递归结束条件
{
Clerk clerk = (Clerk)al.get(left);
float key = clerk.getSalary();
while(i<j)//一趟快速排序
{
while(i<j && ((Clerk)al.get(j)).getSalary() >= key)
{
j--;
}
if(i<j)
{
al.set(i,al.get(j));
i++;
}
while(i<j && ((Clerk)al.get(i)).getSalary() <= key)
{
i++;
}
if(i<j)
{
al.set(j, al.get(i));
}
}
al.set(i, clerk);
Qsort(left, i-1);
Qsort(i+1, right);
}
} //统计员工的平均工资、最高工资和最低工资
public void calSalary()
{
float totalSal = 0;
float minSal = ((Clerk)al.get(0)).getSalary();
float maxSal = ((Clerk)al.get(0)).getSalary(); for(int i=0; i<al.size(); i++)
{
Clerk clerk = (Clerk)al.get(i);
totalSal += clerk.getSalary();
if(minSal > clerk.getSalary())
{
minSal = clerk.getSalary();
}
if(maxSal < clerk.getSalary())
{
maxSal = clerk.getSalary();
}
}
System.out.println(al.size()+"个人的平均薪资为:" + totalSal/al.size());
System.out.println(al.size()+"个人的最低薪资为:"+minSal);
System.out.println(al.size()+"个人的最高薪资为:"+maxSal);
}
}
//员工类
class Clerk
{
private String name;
private String sex;
private int age;
private String no;
private float salary; public Clerk(String name, String sex, int age, String no, float salary)
{
this.name = name;
this.sex = sex;
this.age = age;
this.no = no;
this.salary = salary;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getSex() {
return sex;
} public void setSex(String sex) {
this.sex = sex;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public String getNo() {
return no;
} public void setNo(String no) {
this.no = no;
} public float getSalary() {
return salary;
} public void setSalary(float salary) {
this.salary = salary;
}
}
B.命令行贪吃蛇
java oop 集合框架的更多相关文章
- java的集合框架最全详解
java的集合框架最全详解(图) 前言:数据结构对程序设计有着深远的影响,在面向过程的C语言中,数据库结构用struct来描述,而在面向对象的编程中,数据结构是用类来描述的,并且包含有对该数据结构操作 ...
- java.util 集合框架集合
java的集合框架为程序提供了一种处理对象组的标准方式.设计了一系列标准泛型接口: ⑴Collection ()接口,扩展了Iterable接口,位于集合层次结构的顶部,因此所有的集合都实现Colle ...
- Java基础——集合框架
Java的集合框架是Java中很重要的一环,Java平台提供了一个全新的集合框架.“集合框架”主要由一组用来操作对象的接口组成.不同接口描述一组不同数据类型.Java平台的完整集合框架如下图所示: 上 ...
- java的集合框架之一
java是一套很成熟的东西,很多商用的东西都喜欢用它,用的人多,稳定.不过一般也不怎么说起它,因为太常见了,私下里说,写java应用层得就像农民工,每一处都是搭积木,根据设计师的东西如何优雅地搭好积木 ...
- 浅谈Java的集合框架
浅谈Java的集合框架 一. 初识集合 重所周知,Java有四大集合框架群,Set.List.Queue和Map.四种集合的关注点不同,Set 关注事物的唯一性,List 关注事物的索引列表,Q ...
- java的集合框架set 和map的深入理解
Java的集合框架之Map的用法详解 Map有两种比较常用的实现:HashMap 和 TreeMap. HashMap: HashMap 也是无序的,也是按照哈希编码来排序的,允许使用null 值和n ...
- Java 高级-集合框架
参考资料 参考 HashMap 类似 C++ 中的 STL 标准模板库,Java 也在 java.util 包中封装了一套常用数据结构及其算法,称为集合框架.所有的集合框架都包含如下内容: 接口:代表 ...
- Java 之 集合框架(JCF)
1.集合框架 a.框架:为了实现某一目的或功能,而预先提供的一系列封装好的.具有继承或实现关系的类与集合 b.集合:①定义:Java中对一些数据结构和算法进行封装,即封装(集合也是一种对象) ②特点: ...
- 十五、Java基础---------集合框架体系以及List
在介绍集合之前先说一下数组,正如我们所知,数组是某一类型数据的集合,强调的是数据,而且必须单一:集合框架的不同之处在于存储的数据类型没有任何限制,既可以存储基本数据类型(会自动提升为相应的包装类)也可 ...
随机推荐
- 基于.Net进行前端开发的技术栈发展路线(三)
前言 上一篇<我的技能树二>文章分享了我的技能中的前端技能和Java技能,今天继续跟大家分享的就是后端技能了. 我的技能树 我当前的技能树: 其中,标注为黄色旗帜的是基本掌握,标注为红色旗 ...
- WPF TabControl Unload俩次的解决方案
WPF中,有些控件会多次触发Unload,有点莫名其妙~ Unload的多次触发 TabControl的内容,我是这么设置的: 在TabItem的CacheSettingView中,监听Loaded/ ...
- linux yum配置代理
yum里面可以单独设置代理就是yum源的参数加proxy=“http://ip:PORT”即在/etc/yum.conf中加入下面几句.proxy=http://210.45.72.XX:808pro ...
- Java开发笔记(七十七)使用Optional规避空指针异常
前面在介绍清单用法的时候,讲到了既能使用for循环遍历清单,也能通过stream流式加工清单.譬如从一个苹果清单中挑选出红苹果清单,采取for循环和流式处理都可以实现.下面是通过for循环挑出红苹果清 ...
- nginx系列5:nginx的请求处理流程
nginx的请求处理流程 如下图: nginx可以处理来自web(http),Email,TCP/UDP的三类请求. nginx底层使用非阻塞的事件驱动引擎,结合状态机来完成异步通知,其中处理Http ...
- HTML5利用canvas,把多张图合并成一张图片
需求分析,根据当前网页中的几张图片,在手机上长按,保存图片到相册或者发送给好友. drawCanvas(){ var self = this; var imgsrcArray = [ require( ...
- 驰骋工作流引擎JFlow与activiti的对比之2种取消模式
1. 取消模式(Cancel Activity) 就是将某个活动取消. JFLOW中,类似与删除流程操作相同. 不能删除:不允许删除. 逻辑删除:仅仅将此流程标记为删除状态,数据仍然存在节点表单与流程 ...
- Arcgis for js开发之直线、圆、箭头、多边形、集结地等绘制方法
p{ text-align:center; } blockquote > p > span{ text-align:center; font-size: 18px; color: #ff0 ...
- H-ui框架信息图标点击跳出页面问题
在html中为消息a标签添加id: 在static/h-ui/js/H-ui.min.js添加事件:
- 从头认识一下docker-附带asp.net core程序的docker化部署
从头认识一下docker-附带asp.net core程序的docker化部署 简介 在计算机技术日新月异的今天, Docker 在国内发展的如火如荼,特别是在一线互联网公司, Docker 的使用是 ...