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
在介绍集合之前先说一下数组,正如我们所知,数组是某一类型数据的集合,强调的是数据,而且必须单一:集合框架的不同之处在于存储的数据类型没有任何限制,既可以存储基本数据类型(会自动提升为相应的包装类)也可 ...
随机推荐
- 浅谈cookie和session
Cookie简介 Cookie(复数形态Cookies),中文名称为“小型文本文件”,指某些网站为了辨别用户身份或存储用户相关信息而存储在用户本地终端(Client Side) 上的数据(通常为加密数 ...
- CSS 渐变色
CSS linear-gradient() 函数 http://www.runoob.com/cssref/func-linear-gradient.html CSS radial-gradient( ...
- 博弈论进阶之Every-SG
Every-SG 给定一张无向图,上面有一些棋子,两个顶尖聪明的人在做游戏,每人每次必须将可以移动的棋子进行移动,不能移动的人输 博弈分析 题目中的要求实际是"不论前面输与否,只要最后一个棋 ...
- 微信小程序（五） 利用模板动态加载数据
利用模板动态加载数据,其实是对上一节静态数据替换成动态数据:
- asp.net core自定义端口
asp.net Core 自定义端口 官方文档 aspnet内库源码: https://github.com/aspnet dotnet系统内库源码:https://github.com/dotnet ...
- Delphi连接MySql（待测试验证，使用mysql.pas未通过）
要在一个Delphi程序中调用Mysql数据库,查到有个资料如下,待验证,验证后会给出结果.暂时做个标记 已经验证,验证日期:2018.6.18 验证结果:不可行 验证工具:XE7,mysql5.5. ...
- MongoDB 中的【加减乘除】运算
很多同学因为对MongoDB不熟悉,加之应用的不是很多,有时候会认为MongoDB数据库对一些功能不支持,或者认为支持不好.今天我们 演示一下 MongoDB对“加减乘除”的使用. 在MongoDB数 ...
- Python第五天 文件访问 for循环访问文件 while循环访问文件 字符串的startswith函数和split函数 linecache模块
Python第五天 文件访问 for循环访问文件 while循环访问文件 字符串的startswith函数和split函数 linecache模块 目录 Pycharm使用技巧( ...
- SQL Server查看视图定义总结
在SQL Server中如何查看数据库视图的定义呢? 其实官方文档已经有一个较详细的总结了,这里在官方文档的基础上,我们再深入展开分析一下,例如如何获取系统视图的定义.知其然知其所以然吗. 1:使 ...
- IOS开发protocol使用
1.什么是protocol? protocol(协议)是用来定义对象的属性和行为,用于回调. 2.protocol分类? 协议中有三个修饰关键字@required和@optional和@propert ...