一、获取当前时间，转换字符串 和 字符串转换时间
public static void main(String[] args) throws ParseException{
String d="2018-06-28 19:20:56";
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
//时间转字符串用 .format
Date date1=sdf.parse(d);
//字符串转时间用 .parse
System.out.println(date1);
}
public static void main(String[] args) throws ParseException{
String time="20101125102503";
//String类型的字符串
SimpleDateFormat formatter1=new SimpleDateFormat("yyyy-HH-dd HH:mm:ss");
//new一个时间格式对象
SimpleDateFormat formatter2=new SimpleDateFormat("yyyyHHddHHmmss");
//new一个时间格式对象
time=formatter1.format(formatter2.parse(time));
//formatter2对象的方法把parse(time)转换成formatter2样式的时间格式
//formatter1对象的方法format()，把formatter2.parse(time)时间类型，转换成字符串类型的格式
System.out.println(time);
}
二、集合数组 （分为两类：类一、存放单值数据，类二、存放键值对数据）
存放单值类数组： 1. 数组， 2. ArrayList， 3. HashSet
1.数组 （属性：固定大小、单值、有序、可重复）
- 创建：数据类型[] 变量名=new 数据类型[需要存放数据的个数]
- 赋值：变量名[下标]=值
- 取值：变量名[下标]
注意事项：存数组的时候，不能超过实际设置的下标的值！不然程序执行的时候会报错误
String[] la = new String[3];
// 定义一个数组，然后取数组下标进行赋值
la[0] = "aaa";
la[1] = "bbb";
la[2] = "ccc";
la[3]="ddd";//这是一个错误的赋值，不能赋值超过数组容器的数量
String[] lala = { "a001", "b001", "c001" };
// 定义一个String数组，并直接赋值
Integer[] ss = new Integer[2];
// 定义一个整数类型的数组，整数类型用integer而不是用int
ss[0] = 1;
ss[1] = 2;
for (int i = 0; i < la.length; i++) {
System.out.println(la[i]);
//for循环打印出数组中存的所有的值，如果没有存，默认打印0
}
int a = 0;
while (a < la.length) {
System.out.println("while循环：" + la[a]);
a++;
}
2. ArrayList （属性：不固定大小、单值、有序、可重复）
- 创建：List<泛型>] 变量名=new ArrayList<泛型>();
- 赋值：变量名.add(对应的数组类型);
- 取值：变量名.get(数据位置);
List<String> arr = new ArrayList<String>();
//动态大小、有序、单值，用list数组，ArrayList向上转型为list
arr.add("这是一个list数组");//.add()；存值
arr.add("这是第二个list");
arr.add("这是第三个list");
for (int b = 0; b < arr.size(); b++) {
//除了数组arrer用length，全用size()获取数组中存的的数据的个数
System.out.println("这是一个list数组的for循环：" + arr.get(b));
}
int a = 0;
while (a < arr.size()) {
System.out.println("这是list的while循环" + arr.get(a));
a++;
}
- Set（属性：不固定大小、单值、无序、值去重）
- 创建：Set<泛型>] 变量名=new HashSet<泛型>();
- 赋值：变量名.add(对应的数组类型);
- 取值：因为Set数组是无序的，所以要用foreach遍历出来，或者用数组自带的排序方法 .iterator();，给自身进行排序，然后用排序后的.hasNext方法，进行取值
Set<String> Str = new HashSet<String>();
// new一个Set类型的存储空间
Str.add("SetNo1");
Str.add("SetNo2");
Str.add("SetNo3");
Iterator<String> IteStr = Str.iterator();
// 无序的数组做取数据之前，要给无序的数组排序，每个数组都有自己的排序方法Iterator()
// 先写数组本身的排序方法Str.iterator()，鼠标放在上面即可看见返回的数据类型为:Iterator<String>
while (IteStr.hasNext()) {
// 因为数组中存的值的个数不固定，只能用while循环和foreach遍历
// 排序后的数据，自带hasNext方法，意思是：是否有下一个，返回结果为true则执行，取值为，naxt 下一个
String cc = IteStr.next();
if (cc.equalsIgnoreCase("setno3")) {
// if(cc.contains("SetNo3"))，包含的意思，
// equals:相等的意思
//equals() 大小写敏感，equalsIgnoreCase，大小写不敏感
System.out.println(cc);
break;
}
}
for (String st : Str) {
//foreach 遍历
if (st.contains("SetNo2")) {
// 只有全部的数据都要取，才用for遍历
System.out.println(st);
break;
}
}
泛型：广泛的类型！
定义一个数组，我们不光要在内存中划分存储的空间，还要确定这个数组存的什么类型的数据，虽然不加泛型可以存各种类型的值，但是取数据的时候怎么办？
存放键值对类数组： 1. Javabean 2. HashMap
- javabean （属性：键值对，固定大小，引用自写类属性、方法）
- 创建：方法名 变量名=new 方法名();
- 赋值：方法名.属性名字=属性名对应的类型的值 or 方法名.set属性名(属性名对应的值);
- 取值：方法名.get(属性名);
//这是自写的类，封装了属性和属性的set()、 get()方法
public String Name ;
public String getName() {
return Name;
}
public void setName(String name) {
Name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int age;
@Override
public String toString() {
return "Person [Name=" + Name + ", age=" + age + ", getClass()="
+ getClass() + ", hashCode()=" + hashCode() + ", toString()="
+ super.toString() + "]";
}
这是Javabean写法
Person per = new Person();
// 这是一个Javabean数组，把自己定义的类给new出来，使用里面的属性和方法
per.age = 18;
per.setName("顾虹雁");
// 两种方法给new出来属性赋值
System.out.println(per.getAge()+" 这是Javabean的get取值");
System.out.println("这是我女神的名字："+per.getName());
//age 和 name 的get方法，分别取值打印
String Result = per.toString();
// 调用Person类下的toString方法，把赋的值打印出来
System.out.println("这是一个javabean:" + Result);
- HashMap（属性：动态大小，键值对，key去重,无序存放数据）
- 创建：Map<key数据类型,value数据类型> map=new HashMap<key数据类型,value数据类型>();
- 赋值：变量名.put(key,value);
- 取值：因为HashMap数组是无序的，所以要用foreach遍历出来，或者用数组自带的排序方法 .iterator();，给自身进行排序，然后用排序后的.hasNext方法，进行取值
Map<String, String> map = new HashMap<String, String>();
// 增加数据
map.put("name", "guoya");
map.put("age", "1");
map.put("addr", "上海浦江镇");
// 修改数据
map.put("addr", "上海市闵行区浦江镇");
// 取单个：
String name = map.get("name");
String age = map.get("age");
// 通过entrySet()方法将map集合中的映射关系取出（这个关系就是Map.Entry类型）
Set<Entry<String, String>> mapentry = map.entrySet();
// 将关系集合entrySet进行迭代，存放到迭代器中
Iterator<Entry<String, String>> it = mapentry.iterator();
// 简写HashMap调用迭代器的方法
// Iterator<Map.Entry<String, String>> iterator =
// map.entrySet().iterator();
while (it.hasNext()) {
// 获取Map.Entry关系对象item
Map.Entry<String, String> item = it.next();
// 通过关系对象获取key
String key = item.getKey();
// 通过关系对象获取value
String value = item.getValue();
}
