------- android培训、java培训、期待与您交流！ ----------
前言：通过观看毕向东老师的java基础视频，查漏补缺，将一些自己掌握的还不牢固的知识写出来，希望和大家交流分享。
1.基本数据类型包装类
1.java定义该类的原因：基本数据类型封装成对象的好处，在于可以在对象中定义更多的功能方法操作该数据。
最常见作用，就是用于基本数据类型和字符串类型之间做转换。
2.基本数据类型对象包装类。
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| boolean | Boolean |
| float | Float |
| double | Double |
| char | Character |
3.基本数据类型转成字符串
两种方式：
1）基本数据类型+" "
2）基本数据类型.toString(基本数据类型值)；
如：Integer.toString(34);//将34整数变成"34"。
4.字符串转成基本数据类型。xxx a = Xxx.parseXxx(string);//必须传入对应类型的字符串。
如：
int a = Integer.parseInt("123");//静态
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();//跟上面的静态方式的结果一样，但这种属于对象调用方式。注意：
在使用时，Integer x = null;上面的代码就会出现NullPointerException。
5.十进制转成其他进制。toBinaryString();
toHexString();
toOctalString();
6.其他进制转成十进制。parseInt(String,radix);
如：int a= Intager.parseInt("3c",16);
7.自动装箱和拆箱
这是JDK1.5版本以后出现的新特性。
Integer x=new Integer(4);
等效于：Integer x=4;//自动装箱。
还可以直接进行运算：x=x+2;//x进行自动拆箱。变成了int类型。和2进行加法运算。再将和进行装箱赋给x。x的拆箱动作等效：x.intValue()。
2.泛型
1.用于解决安全问题，是一个类型安全机制。它是DJK1.5以后出现的版本。它希望在定义集合时，明确表明你要向集合中装入那种类型的数据，
无法加入指定类型以外的数据。
2.泛型是提供给javac编译器使用的可以限定集合中的输入类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响，对参数化的泛型类型，
getClass()方法的返回值和原始类型完全一样。
3.由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，如用反射得到集合，再调用add方法即可。
4.使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。
5.格式：通过<>来定义要操作的引用数据类型
如：ArrayList<String> //定义要存入集合中的元素指定为String类型
6. 好处：
a、将运行时期出现的问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时期问题减少、安全。
b、避免了强制转换的麻烦。如在实现某一个接口时，指定传入接口方法的实参的类型的话，在复写该接口方法时就可以直接使用指定类型，而不需要强制转换。
7.引入泛型后，要注意 只有类被定义成了泛型，才可以对其进行参数化应用。
package reflect;
public class Test {
public void func(){
System.out.println("func");
}
public static void main(String[] args) throws Exception{
Object obj = new Test();
//可以成功编译
((Test)obj).getClass().newInstance().func();
//下面这两行无法通过编译 。原因：是因为((Test)obj).getClass()返回的为对象类型为Class<? extends Test>，
//但是我们在第一行将结果强制转换成了Class，然后再去调用Class的newInstance方法，而不是去调用Class<Test>的
//newInstance方法，编译器当然不再认为Class的newInstance方法返回的对象为Test了。
//Class c = ((Test)obj).getClass();
//c.newInstance().func();
//下面这两行可以成功编译 ,因为泛型编译器可以在编译期获得类型信息所以可以编译这类代码。
Class<? extends Test> c = ((Test)obj).getClass();
c.newInstance().func();
}
}
ArrayList<E>：泛型类型，E称为类型变量或类型参数
ArrayList<Integer>：参数化类型，Integer称为类型参数的实例或实际类型参数，<>称为typeof
ArrayList称为原始类型
9.什么时候写泛型？集合框架中很常见，只要见到<>就要定义泛型。
10.几点说明：
1）参数化类型与原始类型的兼容性
参数化类型可引用一个原始类型的对象，原始类型可引用一个参数化类型的对象
Collection<String>coll = new Vector(); //警告
Collection coll = new Vector<String>(); //警告
2）参数的类型不考虑类型参数的继承关系
Vector<String> v = newVector<Objec>();//错误
Vector<Objec> v = newVector<String>();//错误
3）编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型
如：Vector<Integer>vectorList[] = new Vector<Integer>[10];//错误
11.通配符：传入的类型不确定时，可以使用通配符‘？’，可以理解为占位符。使用通配符的好处是可以不用明确传入的类型，
这样在使用泛型类或者泛型方法时，提高了扩张性。
/*
* Collection<?>a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，
* 所以：a=newArrayList<Integer>和a=new ArrayList<String>都可以，
* 但a.add(new Date())或a.add(“abc”)都不行。
*/
public static void printCollection(Collection<Object> cols) {
for (Object object : cols) {
System.out.println(object);
}
cols.add("String");//没错
cols = new HashSet<Date>();//错误
}
public static void printCollection1(Collection<?> cols) {
for (Object object : cols) {
System.out.println(object);
}
cols.add("String");//错误，因为它不知自己未来匹配就一定是String
cols = new HashSet<Date>();//正确
}12.泛型限定 : 对于一个范围内的一类事物，可以通过泛型限定的方式定义，有两种方式：
1）? extends E：可接收E类型或E类型的子类型；称之为上限。
如：ArrayList<? extends Number>x = new ArrayList<Integer>();
2）? super E：可接收E类型或E类型的父类型；称之为下限。
如：ArrayList<? super Integer>x = new ArrayList<Number>();
13.泛型类1）当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展
2）若类实例对象中要使用到同一泛型参数，即这些地方引用类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型。
3）泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所以要操作的类型就已经固定了。
4）泛型类语法格式： class Utils<T>{
private T s;
public void setXx(T s){
this.s=s;
}
public T getXx(){
return s;
}
}5）在对泛型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
6)当一个变量被声明为参数时，只能被实例变量和方法调用（还有内嵌类型），而不能被静态变量和静态方法调用，因为静态成员是被所有参数化的类共享的，
所以静态成员不应该有类级别的类型参数。
14.泛型方法：为了让方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。 如下面程序。
class Demo<Q> {
public void run(Q q){}
public <T> void show(T t) {}//方法中上的泛型可以不和类泛型相同
public static <W> void function(W w){}
public static void method(Q w){}
//Cannot make a static reference to the non-static type
//静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
}
特点：
1、位置：用于放置泛型的类型参数的<>应出现在方法的其他所有修饰符之后和方法的返回类型之前，也就是紧邻返回值之前，
按照惯例，类型参数通常用单个大写字母表示。
2、只有引用类型才能作为泛型方法的实际参数,基本类型不可以。
3、除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符。例如，Class.getAnnotation()方法的定义。
并且可以用&来指定多个边界，如<V extends Serializable& cloneable> void method(){}。
4、普通方法、构造函数和静态方法中都可以使用泛型。
5、可以用类型变量表示异常，称之为参数化的异常，可用于方法的throws列表中，但是不能用于catch子句中。
6、在泛型中可同时有多个类型参数，在定义它们的<>中用逗号分开。例如：
public static <K,V> V getValue(K key) { return map.get(key);}
15.T和?的区别
1、T限定了类型，传入什么类型即为什么类型，可以定义变量，接收赋值的内容。
2、?为通配符，也可以接收任意类型但是不可以定义变量。
但是这样定义，虽然提高了扩展性，可还是有一个局限性，就是不能使用其他类对象的特有方法。
通配符方案要比泛型方法更有效，当一个类型变量用来表达两个参数之间或参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，
或者类型变量在方法体代码中也被使用，而不是仅在签名的时候使用，才需要使用泛型方法。
16.什么时候使用泛型类和泛型方法：
2）泛型类：如果类型确定后，所操作的方法都是属于此类型，则定义泛型类。
3）泛型方法：如果定义的方法确定了，里面所操作的类型不确定，则定义泛型方法。
17.泛型的应用两例
1）通过反射获取泛型的参数化类型
package generic;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.Date;
import java.util.Vector;
/**
*通过反射获取泛型的参数化类型
* @author songwenju
*/
public class GenericalReflection {
private Vector<Date> dates = new Vector<Date>();
public void setDates(Vector<Date> dates){
this.dates = dates;
}
public Vector<Date> getDates() {
return dates;
}
public static void main(String[] args) throws Exception {
Method method = GenericalReflection.class.getDeclaredMethod("setDates", Vector.class);
ParameterizedType pType = (ParameterizedType)(method.getGenericParameterTypes())[0];
System.out.println("setDate("
+((Class)pType.getRawType()).getName()+"<"
+((Class)(pType.getActualTypeArguments())[0]).getName()
+">)");
}
}
运行结果：
2）泛型的DAO应用
package generic;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
interface DaoBase<T>{}
/**
* 泛型的DAO应用
* @author songwenju
* @param <T>
*/
public abstract class DaoBaseImpl<T> implements DaoBase<T>{
protected Class<T> clazz;
public DaoBaseImpl() {
Type type = this.getClass().getGenericSuperclass();
ParameterizedType pType = (ParameterizedType) type;
this.clazz = (Class<T>) pType.getActualTypeArguments()[0];
System.out.println("clazz = "+this.clazz);
}
}
3.Collections
1.Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象。并未封装特有数据。
2. 在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。
3.常见操作
1）查找
T max(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象 void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素 3）排序：
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4）反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
ComparatorreverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序 5）同步的集合
List<T>synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合
Map<K,V>synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口：
List：对元素都有定义索引。有序的。可以重复元素。Set：不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法
5)通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。6）使用Collections中的方法fill对List集合中的部分元素进行替换，代码实例：
package generic;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 需求：使用Collections中的方法fill对List集合中的部分元素进行替换
* 思路：1、将List集合中要替换的部分元素取出,并存入另一集合中
* 2、将原集合中的要替换元素移除
* 3、用fill将要替换的元素进行替换
* 4、将取出的部分增加进集合
* @author songwenju
*/
@SuppressWarnings("serial")
//自定义异常
class InputException extends Exception{
public InputException(String massage) {
super(massage);
}
}
public class FillTest {
//替换部分元素的方法。
public static void fillSome(List<String> list,int start,int end,String string)throws InputException {
if (start >= end) {
throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常
}
//定义一个新集合
List<String> li = new ArrayList<String>();
//因为每移除一次，后面的元素就会补上，所以这里用j来控制次数
for (int i = start,j = start; j < end; j++) {
li.add(list.get(i));//将需要替换的元素增加到新集合
list.remove(i);//移除需要替换的元素
}
Collections.fill(li, string);//替换成需要的元素s
list.addAll(start, li);//将替换的部分增加进原集合
}
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("ab");
list.add("abcd");
list.add("a");
list.add("abcde");
try {
fillSome(list, 1, 5, "song");
} catch (InputException e) {
System.out.println(e.toString());
}
System.out.println(list);
}
}
4.Arrays类
1.Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
2.把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。
3.常见方法
1）Lsit<T> asList(T... a);//将数组转换为集合
注意：
a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生UnsupportedOperationException的编译异常。
b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
2）binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，
并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3）String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
4.Arrays相关操作package arrays;
import java.util.Arrays;
import java.util.List;
/**
* Arrays相关操作
* @author songwenju
*
*/
public class ArraysDemo {
public static void main(String[] args) {
int[] arr = {2,4,5};
System.out.println("arr.toString():"+arr.toString());
//转换为字符串形式
System.out.println("Arrays.toString(arr):"+Arrays.toString(arr));
String []arrStrings = {"abc","cc","kkk"};
List<String> list = Arrays.asList(arrStrings);
//判断是否存在"cc"这个元素
System.out.println("arrStrings是否包含 cc:"+list.contains("cc"));
Integer[] nums = {7,8,9};
List<Integer> list2 = Arrays.asList(nums);
System.out.println("asList方法将Integer[]转集合："+list2);
}
}
运行结果：
5.集合变数组：Collection接口中的toArray方法。 <T> T[] toArray(T[] a);将集合变为指定类型的数组。
1）指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2）为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
6.将集合类转换为数组package arrays;
import java.util.ArrayList;
import java.util.Arrays;
/**
* 将集合类转换为数组
* @author songwenju
*
*/
public class CollectionToArray {
public static void main(String[] args) {
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
//将集合变为String数组
String[] arr = al.toArray(new String[al.size()]);
//利用Arrays操作数组的方法
System.out.println(Arrays.toString(arr));
}
}
7.foreach格式：
for(数据类型变量名 :被遍历的集合（collection）或者数组)
{
执行语句
}1）对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。可以看作是迭代器的简写形式。
2）迭代器除了遍历，还可以进行remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。
3）高级for有一个局限性。必须有被遍历的目标（集合或数组）。传统for遍历数组时有索引。8.方法的可变参数
如果一个方法在参数列表中传入多个参数，个数不确定，那么每次都要复写该方法。这时可以用数组作为形式参数。但是在传入时，每次都需要定义一个数组对象，作为实际参数。在JDK1.5版本后，就提供了一个新特性：可变参数。
可变参数其实就是数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
在使用时注意：可变参数一定要定义在参数列表的最后面。
package arrays;
import java.util.Arrays;
/**
* 可变参数其实就是数组
* @author songwenju
*
*/
public class ParaMethodDemo {
/**
* 可变参数方法
* @param str
* @param arr
*/
public static void show(String str,int...arr) {
System.out.println("参数为"+str+","+Arrays.toString(arr));
}
public static void main(String[] args) {
show("ooxx", 2,3,4,5,6,7,8);
}
}
运行结果：
9.静态导入
1）写法：
import static java.util.Arrays.*;//导入的是Arrays这个类中的所以静态成员。
import static java.lang.System.*//导入了Ssytem类中所以静态成员。
没加static导入的是类，加上static导入的全是某一个类中所以的静态成员。这样写在调用该类的静态方法时可以不用再写类名。如：Arrays.sort(数组);就可以直接写sort(数组);
2）注意：
当导入的两个类中有同名成员时，需要在成员前加上相应的类名。
当类名重名时，需要指定具体的包名。当方法重名时，指定具体所属的对象或者类。
package arrays;
import static java.util.Arrays.*;
import static java.lang.System.*;
import java.util.Arrays;
/**
* 使用静态导入，对于使用工具类很方便，他省略了类名，使更简洁。
* 对于不能区分具体哪个类的方法要加上类名。
* @author songwenju
*
*/
public class StaticImport {
public static void main(String[] args) {
//打印输出时就可以直接省略书写System.
out.println("songwenju");
int[] arr = {3,1,5};
//使用Arrays工具类的方法sort时就可以省略书写Array.
sort(arr);
int index = binarySearch(arr, 1);
out.println("index="+index);
//当没有指定继承时，所以类默认继承了Object，
//因为toString方法都具备，所以为了区分，必须写上具体调用者
out.println(Arrays.toString(arr));
}
}
5.System类
1.System是描述系统一些信息的类，类中的属性和方法都是静态的。不能被实例化，没有提供构造函数。
2.字段：out：标准输出流。默认是控制台。in：标准输入流。默认是键盘。
3.常用方法
1）获取系统的属性信息：
Properties getProperties();
说明：
a）此方法返回的双列集合，即键值对；因为Properties是Hahstable的子类，也就是Map集合的一个子类对象，那么通过Map方法取出该集合中的元素。
b）该集合存储的都是字符串，没有泛型定义
2）获取指定属性信息：
String getProperty(Stringkey);
3）在系统内定义特有信息：
String setProperty(Stringkey,String value);
4）如何在jvm启动时，加载一些属性信息：
通过命令：java -D<name>=<value>可以设置特有的系统属性信息
5）System类的常用操作
package javaBase;
import java.util.Map.Entry;
import java.util.Properties;
/**
* System类的常用操作
* @author songwenju
*
*/
public class SystemDemo {
public static void main(String[] args) {
//获取当前的系统属性
Properties p = System.getProperties();
//Map集合输出
for ( Entry<Object, Object> s: p.entrySet()) {
System.out.print(s.getKey()+"————>");
System.out.println(s.getValue());
}
//分割线
System.out.println("---------------------");
//获取指定键指示的系统属性
String value = System.getProperty("os.name");
System.out.println("os.name:"+value);
//设置指定键指示的系统属性信息
System.setProperty("os.name", "win8.1");
value = System.getProperty("os.name");
System.out.println("os.name:"+value);
//当系统中没有该键值，返回null
value = System.getProperty("swj");
System.out.println("swj:"+value);
}
}
6.Runtime类
1.每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的。
2.该类中并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。查阅API文档发现，该类中还有非静态方法。说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型。由以上特点可以看出该类使用了单例设计模式完成。
3.常用方法：
1）获取本类对象
static Runtime getRuntime();
2）在单独的进程中执行指定字符串命令
Process exec(String command);
3）在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束
void destroy();
4.代码示例：package javaBase;
/**
* 打开记事本，三秒后关闭
* @author songwenju
*
*/
public class RuntimeDemo {
public static void main(String[] args) throws Exception {
//获取本类对象
Runtime r = Runtime.getRuntime();
//执行记事本程序
Process p = r.exec("notepad.exe");
//用记事本打开指定文件
Process p1 = r.exec("notepad.exe D:/v5/File.java");
//让线程等待3秒
Thread.sleep(3000);
//杀掉指定进程,关闭窗口
p.destroy();
Thread.sleep(3000);
p1.destroy();
}
}
1.Date类：
1）表示特定的瞬间，精确到毫秒。 java中的默认显示格式为：Tue Jun 30 15:28:28 CST 2015
Date date = new Date();
System.err.println(date);//Tue Jun 30 15:28:28 CST 2015 3)创建自定义格式的步骤：
a）创建Date对象
b）将时间模式封装到SimpleDateFormat对象中
c）调用format方法让格式化模式指定Date对象
代码示例：
package javaBase;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
//创建Date对象
Date date = new Date();
System.err.println(date);
//创建SimpleDateFormat对象，将模式封装到SimpleDateformat对象中。
SimpleDateFormat sFormat = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
//format方法返回字符串。
System.out.println(sFormat.format(date));
}
}
2.Calendar类
2）Calendar可以对年月日等时间进行获取。并提供了相应的子段值。
3）常用方法：
a)获取时间
1、获取年份：Calendar.YEAR
2、获取月份：Calendar.MONTH
3、获取日期：Calendar.DAY_OF_MONTH
4、获取星期：Calendar.DAY_OF_WEEK
5、获取小时：Calendar.HOUR_OF_DAY
6、获取分钟：Calendar.MINUTE
7、获取秒数：Calendar.SECOND
b)设置时间：
1、根据日历的规则，为给定的日历字段添加或减去指定的时间量：
void add(int field,int amount);
2、获取指定的日历字段对应的时间值：
int get(int field);
3、将给定日历字段对应的时间值设置为给定值：
void set(int field,int value);
4、设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值：
void set(int year,int month,int date);
package javaBase;
import java.util.Calendar;
/**
* Calendar类
* @author songwenju
*
*/
public class CalendarDemo {
public static void main(String[] args) {
//该类是一个抽象类，不能直接new
Calendar c = Calendar.getInstance();
//指示年的 get 和 set 的字段数字。这是一个特定于日历的值。不是直接的年
System.out.println("常数Calendar.YEAR:"+Calendar.YEAR);//1
System.out.println("年——>"+c.get(Calendar.YEAR));
System.out.println("常数Calendar.MONTH:"+Calendar.MONTH);
System.out.println("月——>"+(c.get(Calendar.MONTH)+1));
System.out.println("日——>"+c.get(Calendar.DAY_OF_MONTH));
String []week = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
System.out.println(week[c.get(Calendar.DAY_OF_WEEK)]);
}
}
8.Math类
1. Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。该类全为静态方法。
2.常用方法：
1）double ceil(double d);//返回大于指定数据的最小整数
2）double floor(double d);//返回小于指定数据的最大整数
3）double pow(doublea,double b);//返回a的b次方
4）long round(doubleb);//返回b四舍五入的值
5）double random();//返回正号的double值，是一个大于等于0.0且小于1.0的随机数
3.Random类：这是java.util中的一个单独的类，该类对象用于获取随机数。与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。
如：int nextInt(int n);//返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
4.代码示例：package javaBase;
/**
* 需求：给定一个小数，保留该小数的后n位。
* 1、先把给定小数乘以10的n次方，四舍五入保留整数部分
* 2、再把该整数除以10的n次方
* @author songwenju
*
*/
public class MathDemo {
//保留小数位方法
public static double retention(double d,int n) {
double d1=d*Math.pow(10,n);//先将要保留的小数位变为整数
long l=Math.round(d1);//将小数四舍五入
return l/Math.pow(10,n);//返回保留了指定小数位的小数
}
public static void main(String[] args) {
double d = retention(3.141592, 3);
System.out.println("d = "+d);
}
}
------- android培训、java培训、期待与您交流！ ----------
852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
