第十三天
Java API是运行库的集合,它提供了一套访问主机系统资源的标准方法。即给开发人员使用的现成方法。
String类
字符串是一个特殊的对象。
String str = “abc”;//s1是一个类类型变量, "abc"是一个对象。
//字符串最大特点:一旦被初始化就不可以被改变。
String str1 = new String(“abc”);//两个对象。
String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。
常见的操作有哪些?
"abcd"
1,获取。
1.1 字符串中的包含的字符数,也就是字符串的长度。
int length():获取长度。
1.2 根据位置获取位置上某个字符。
char charAt(int index)://当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
1.3 根据字符获取该字符在字符串中位置。
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始,获取ch在字符串中出现的位置。
//如果没有找到,返回-1.
int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) :从fromIndex指定位置开始,获取str在字符串中出现的位置。
int lastIndexOf(int ch) ://反向索引一个字符出现位置。
2,判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str):
特殊之处:indexOf(str):可以索引str第一次出现位置,如果返回-1.表示该str不在字符串中存在。
所以,也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)
而且该方法即可以判断,有可以获取出现的位置。
2.2 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同,并忽略大小写。
boolean equalsIgnoreCase();
3,转换。
3.1 将字符数组转成字符串。
构造函数:String(char[])
String(char[],offset,count):将字符数组中的一部分转成字符串。
静态方法:
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):
3.2 将字符串转成字符数组。
char[] toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。
3.4 将字符串转成字节数组。
byte[] getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)
//3+"";//String.valueOf(3);
特殊:字符串和字节数组在转换过程中,是可以指定编码表的。
4,替换
String replace(oldchar,newchar);//如果要替换的字符不存在,返回的还是原串。
5,切割
String[] split(regex);(正则表达式)
6,子串。获取字符串中的一部分。
String substring(begin);//从指定位置开始到结尾。如果角标不存在,会出现字符串角标越界异常。
String substring(begin,end);//包含头,不包含尾。s.substring(0,s.length());
7,转换,去除空格,比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);
StringBuffer是字符串缓冲区。
是一个容器。
特点:
1,长度是可变化的。
2,可以字节操作多个数据类型。
3,最终会通过toString方法变成字符串。
1,存储。
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,数据):可以将数据插入到指定index位置。
2,删除。
StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3,获取。
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
4,修改。
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;
5,反转。
StringBuffer reverse();
6,
将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
JDK1.5 版本之后出现了StringBuilder.
StringBuffer是线程同步。
StringBuilder是线程不同步。
以后开发,建议使用StringBuilder
升级三个因素:
1,提高效率。
2,简化书写。
3,提高安全性
第十四天
集合
集合框架:
-Collection
--List :元素是有序的,元素可以重复。因为该集合体系有索引。
---ArrayList :底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
---LinkedList :底层使用的链表数据结构。特点:增删速度很快,查询稍慢。线程不同步。
---Vector :底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
--Set :元素是无序,元素不可以重复。
---HashSet 底层数据结构是哈希表。是线程不安全的。不同步。
---TreeSet 可以对Set集合中的元素进行排序,底层数据结构是二叉树。
为什么出现这么多的存储方式都不同。
应为每一个容器对数据的存储方式都不同。
这个存储方式称之为:数据结构。
Collection方法:
添加元素: boolean add(E e)
删除元素: void clear() 清除所有元素
boolean remove(Object o) 删除单个。
判断元素: boolean contains(Object o) 是否包含指定的元素
boolean isEmpty() 是否不包含元素
获取:
迭代器: Iterator<E> iterator()
返回在此 collection 的元素上进行迭代的迭代器。
Iterator 迭代器里的方法:
boolean hasNext() :如果仍有元素可以迭代,则返回 true。
E next() :返回迭代的下一个元素。
void remove() :从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。
迭代器使用方法:
import java.util.*;
class CollectionDemo//编译的时候会有注意提示,因为没有定义泛型
{
public static void main(String[] args)
{
method_get();
}
public static void method_get()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。
while(it.hasNext())
{
it.next();
it.remove();
//System.out.println(it.next());
}
System.out.println(al+"...");
//for循环替代上面,内存优化,迭代器对象只使用一次就自动释放。
/*for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
*/
}
}
理解迭代器:就如游戏机房里的夹娃娃机器,那个机器里外面的操作杆就是迭代器,
我们只需要操操作杆就可以取出里面的东西。
其实就是定义在集合里的一个内部类接口 Iterator ,对外界提供一个获取内部类对象的方法iterator()。
然后通过该对象里的方法获取集合里的元素等操作。
List:
特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
void add(index,element);在列表的指定位置插入指定元素
boolean addAll(index,Collection);将指定 collection 中的所有元素都插入到列表中的指定位置(可选操作)。
删
E remove(index);移除列表中指定位置的元素
改
E set(index,element);用指定元素替换列表中指定位置的元素
查
E get(index): 返回列表中指定位置的元素
List<E> subList(int fromIndex, int toIndex);返回列表中指定的 fromIndex(包括 )和 toIndex(不包括)之间的部分视图。
int indexOf(obj):获取指定元素的位置。
ListIterator<E> listIterator();List特有迭代器,返回此列表元素的列表迭代器(按适当顺序)。
可以添加元素void add(E e)
List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以,在迭代器时,只能用迭代器的放过操作元素,可是Iterator方法是有限的,
只能对元素进行判断,取出,删除的操作,
如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。
该接口只能通过List集合的listIterator方法获取。
Vector 特有迭代
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
LinkedList:特有方法:
void addFirst(E e);将指定元素插入此列表的开头
addLast();
E getFirst();返回此列表的第一个元素
E getLast();
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
E removeFirst();
E removeLast();
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
boolean offerFirst(E e);在此列表的开头插入指定的元素
offerLast();
E peekFirst();
E peekLast();
获取元素,但不删除元素。如果集合中没有元素,会返回null。
E pollFirst();
E pollLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null
HashSet :
HashSet是如何保证元素唯一性的呢?
是通过元素的两个方法,hashCode和equals来完成。
如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的hashcode值不同,不会调用equals。
注意,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。
自定义存储:
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人,重复元素。
class HashSetTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet hs = new HashSet();
hs.add(new Person("a1",11));
hs.add(new Person("a2",12));
hs.add(new Person("a3",13));
// hs.add(new Person("a2",12));
// hs.add(new Person("a4",14));
//sop("a1:"+hs.contains(new Person("a2",12)));
// hs.remove(new Person("a4",13));
Iterator it = hs.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()
{
System.out.println(this.name+"....hashCode");
return name.hashCode()+age*37;
}
public boolean equals(Object obj)//覆写了比较方法
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
第十五天
TreeSet :
保证元素唯一性的依据:
compareTo方法return 0.
TreeSet排序的第一种方式:让元素(对象)自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
这种方式也称为元素的自然顺序,或者叫做默认顺序。
int compareTo(T o)
比较此对象与指定对象的顺序
代码实现:
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"....compareto....."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
TreeSet(Comparator<? super E> comparator)
构造一个新的空 TreeSet,它根据指定比较器进行排序
Comparator:
int compare(T o1, T o2)
比较用来排序的两个参数。
boolean equals(Object obj)
指示某个其他对象是否“等于”此 Comparator。
代码实现:
class TreeSetDemo
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyCompare);//将比较器传入,是集合更具比较器进行比较
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
Iterator it = ts.iterator();
while(it.hasNext())
{
Student stu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"....compareto....."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class MyCompare implements Comparator//定义自己的比较器
{
public int compare(Object o1,Object o2)
{
Student s1 = (Student)o1;
Student s2 = (Student)o2;
int num = s1.getName().compareTo(s2.getName());
if(num==0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
/*
if(s1.getAge()>s2.getAge())
return 1;
if(s1.getAge()==s2.getAge())
return 0;
return -1;
*/
}
return num;
}
}
泛型:
JDK1.5版本以后出现新特性。用于解决安全问题,是一个类型安全机制。
好处
1.将运行时期出现问题ClassCastException,转移到了编译时期。,
方便于程序员解决问题。让运行时问题减少,安全。,
2,避免了强制转换麻烦。
泛型格式:通过<>来定义要操作的引用数据类型。
ArrayList<String> al = new ArrayList<String>();
在使用java提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,
只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
什么时候定义泛型类?
当类中要操作的引用数据类型不确定的时候,
早期定义Object来完成扩展。
现在定义泛型来完成扩展
泛型前:
class Tool
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public Object getObject()
{
return obj;
}
}
泛型后:
class Utils<T>
{
private T q;
public void setObject(T q)
{
this.q = q;
}
public T getObject()
{
return q;
}
}
泛型类注意:
class Demo<T>//泛型类定义的泛型,在整个类中有效。如果被方法使用,
//那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
{
public void show(T t)
{
System.out.println("show:"+t);
}
public <Q> void print(Q q)//为了让不同方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。
{
System.out.println("print:"+q);
}
//错误public static void method(T t){}//静态方法不可以访问类上定义的泛型。
public static <W> void method(W t)
//如果静态方法操作的应用数据类型不确定,可以将泛型定义在方法上。
{
System.out.println("method:"+t);
}
}
泛型定义在接口上。
interface Inter<T>
{
void show(T t);
}
? 通配符。也可以理解为占位符。
泛型的限定;
? extends E: 可以接收E类型或者E的子类型。上限。
? super E: 可以接收E类型或者E的父类型。下限
-Map<K,V>
--Hashtable :线程安全,速度慢,底层是哈希表数据结构,不允许存放null键,null值,已被HashMap替代
用作键的对象必须实现 hashCode 方法和 equals 方法。
--HashMap :线程不安全,速度快,底层是哈希表数据结构,允许存放null键,null值。
用作键的对象必须实现 hashCode 方法和 equals 方法。
--TreeMap :对键进行排序,底层是二叉树数据结构,排序原理与TreeSet相同。
和Set很像。其实大家,Set底层就是使用了Map集合。
Map与Collection在集合框架中属并列存在
Map存储的是键值对
Map存储元素使用put方法,Collection使用add方法
Map集合没有直接取出元素的方法,而是先转成Set集合,在通过迭代获取元素
Map集合中键要保证唯一性
1,添加。
V put(K key, V value)
void putAll(Map<? extends K,? extends V> m)
2,删除。
void clear()
V remove(Object key)
3,判断。
boolean containsValue(Object value)
boolean containsKey(Object key)
boolean isEmpty()
4,获取。
V get(Object key)
int size() 返回此映射中的键-值映射关系数。
Collection<V> values() 返回此映射中包含的值的 Collection 视图。
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet() 返回此映射中包含的键的 Set 视图。
map集合的两种取出方式:
1,Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
Set<String> keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
}
2,Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,
而这个关系的数据类型就是:Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢?
因为只有有了Map集合,有了键值对,才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
map.put("02","zhangsan2");
map.put("03","zhangsan3");
map.put("01","zhangsan1");
map.put("04","zhangsan4");
Set<Map.Entry<String,String>> entrySet = map.entrySet();//返回一个Set集合
Iterator<Map.Entry<String,String>> it = entrySet.iterator();//得到Set集合迭代器
while(it.hasNext())
{
Map.Entry<String,String> me = it.next();//得带May关系
String key = me.getKey();//通过关系得到Key
String value = me.getValue();//通过关系得到Value
System.out.println(key+":"+value);
}
}
Map.Entry 其实Entry也是一个接口,它是Map接口中的一个内部接口。
interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}
class HashMap implements Map
{
class Hahs implements Map.Entry
{
public Object getKey(){}
public Object getValue(){}
}
}
Map扩展:
HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
让值为一个集合,可以分出层次。
使用TreeMap进行排序:相似TreeSet
因为数据是以键值对形式存在的。
所以要使用可以排序的Map集合。TreeMap。
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
//new StuNameComparator()为比较器
第十七天
集合框架中的工具类:
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection有什么区别?
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法。
它有两个常用的子接口,
List:对元素都有定义索引。有序的。可以重复元素。
Set:不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序,二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时,可以通过该工具类中的同步方法,将线程不安全的集合,转换成安全的。
static <T> void sort(List<T> list, Comparator<? super T> c) //给List集合排序的方法
根据指定比较器产生的顺序对指定列表进行排序。
static <T> void fill(List<? super T> list, T obj)//替换List集合中元素为 T obj
使用指定元素替换指定列表中的所有元素。
static void reverse(List<?> list)
反转指定列表中元素的顺序
static <T> Comparator<T> reverseOrder()
返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器,它强行逆转指定比较器的顺序。
Arrays:用于操作数组的工具类。里面都是静态方法。
asList:将数组变成list集合,即返回一个List集合
把数组变成list集合有什么好处?
可以使用集合的思想和方法来操作数组中的元素。
注意:将数组变成集合,不可以使用集合的增删方法。
因为数组的长度是固定。
contains。
get
indexOf()
subList();
如果你增删。那么会反生UnsupportedOperationException,
String[] arr = {"abc","cc","kkkk"};
List<String> list = Arrays.asList(arr);
如果数组中的元素都是对象。那么变成集合时,数组中的元素就直接转成集合中的元素。
Integer[] nums = {2,4,5};
List<Integer> li = Arrays.asList(nums);
如果数组中的元素都是基本数据类型,那么会将该数组作为集合中的元素存在。
集合变数组。
Collection接口中的toArray方法。
1,指定类型的数组到底要定义多长呢?
当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size,就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2,为什么要将集合变数组?
为了限定对元素的操作。不需要进行增删了。
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String[] arr = al.toArray(new String[al.size()]);//创建一个刚刚好的数组最优
System.out.println(Arrays.toString(arr));
}
}
高级for循环:
格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历,还可以进行remove集合中元素的动作。
如果是用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
System.out.println(i+"::"+hm.get(i));
}
for(Map.Entry<Integer,String> me : hm.entrySet())
{
System.out.println(me.getKey()+"------"+me.getValue());
}
传统for和高级for有什么区别呢?
int[] arr = {3,5,1};
for(int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
}
for(int i : arr)
{
System.out.println("i:"+i);
}
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候,还是希望是用传统for。因为传统for可以定义脚标。
可变参数:
int[] arr = {3,4};
show(arr);
int[] arr1 = {2,3,4,5};
show(arr1);
可变参数。
其实就是上一种数组参数的简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
public static void show(int... arr)//向数组随便穿几个int型数据
public static void show(String str,int... arr)//这种可以。
public static void show(int... arr,String str)//不行
所以int... arr必须定义在后面
静态导入:
当方法不重名:
导入前:
Arrays.toString();
导入后:
import static java.util.Arrays.*;
toString();
当方法重名时,指定具备所属的对象或者类。
toString()方法Object里面有,Arrays里面也有。
导入前:
Arrays.toString();
导入后:
import static java.util.Arrays.*;
Arrays.toString();
当类名不重名时:
import packa.*;
Demo A =new Demo();
当类名重名时,需要指定具体的包名。
import packa.*;
import packb.*;
packa.Demo A =new packa.Demo();
packb.Demo B =new packb.Demo();
System类:静态类
获取系统属性:
static Properties getProperties() :确定当前的系统属性
Properties prop = System.getProperties();
//获取所有属性信息。
for(Object obj : prop.keySet())
{
String value = (String)prop.get(obj);
System.out.println(obj+"::"+value);
}
//因为Properties是Hashtable的子类,也就是Map集合的一个子类对象。
//那么可以通过map的方法取出该集合中的元素。
//该集合中存储都是字符串。没有泛型定义。
static String setProperty(String key, String value) :设置指定键指示的系统属性。
//如何在系统中自定义一些特有信息呢?
System.setProperty("mykey","myvalue");
static String getProperty(String key) :获取指定键指示的系统属性
//获取指定属性信息。
String value = System.getProperty("os.name");//操作系统名称,即Key
System.out.println("value="+value);
//可不可以在jvm启动时,动态加载一些属性信息呢?
String v = System.getProperty("haha");
System.out.println("v="+v);
DOS命令行:
java -Dhaha=qqqq 类名
Runtime对象:单例设计模式运用
该类并没有提供构造函数。
说明不可以new对象。那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的,并返回值类型是本类类型。
由这个特点可以看出该类使用了单例设计模式完成。
该方式是static Runtime getRuntime();
Runtime r = Runtime.getRuntime();
r.exec("notepad.exe SystemDemo.java");//使用记事本打开指定文件
Date类:
import java.util.*;
import java.text.*;
class DateDemo
{
public static void main(String[] args)
{
Date d = new Date();//当前时间
System.out.println(d);//打印的时间看不懂,希望有些格式。
//将模式封装到SimpleDateformat对象中。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
//调用format方法让模式格式化指定Date对象。
String time = sdf.format(d);
System.out.println("time="+time);//打印出来的月是对的,不用+1.
}
}
Calendar 计算机底层的月是0-11月的
因为Date里面方法太多过时了,即用Calendar的方法
import java.util.*;
import java.text.*;
class CalendarDemo
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
c.set(2013,4,12)//4即指5月份
printCalendar(c)
}
public static void printCalendar(Calendar c)
{
//查表法:
String[] mons = {"一月","二月","三月","四月"
,"五月","六月","七月","八月"
,"九月","十月","十一月","十二月"};
String[] weeks = {
"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",
};
int index = c.get(Calendar.MONTH);
int index1 = c.get(Calendar.DAY_OF_WEEK);
sop(c.get(Calendar.YEAR)+"年");
//sop((c.get(Calendar.MONTH)+1)+"月");
sop(mons[index]);
sop(c.get(Calendar.DAY_OF_MONTH)+"日");
//sop("星期"+c.get(Calendar.DAY_OF_WEEK));
sop(weeks[index1]);
}
}
Math 工具类:
double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。
long l = Math.round(12.54);//四舍五入
Math.random()//0-1间的随机数
new Random.nextInt()//免去强转