java内部类、接口、集合框架、泛型、工具类、实现类

 1.成员内部类。

(1)成员内部类的实例化:

外部类名.内部类名   变量名=外部类对象.new 内部类名();

class Person{
  class Test{
   }
 }
 Person p=new Person();
 Person.Test t=p.new Test();

(2)在内部类中访问外部类属性或方法。

  外部类名.this.属性名
   Person.this.name
(3)成员内部类声明的注意事项
  ①内部类不能与外部类重名。
  ②成员内部类中不能出现静态属性,静态方法和静态内部类。
     但是静态常量例外。
 private static final String name="1";//此情况可以使用

复制代码
class Test{//成员内部类
        private  String  name;
        private int age;
        public void say(){
            System.out.println(Person.this.name);//访问外部类的
            System.out.println("Person中的Test的say方法");
        }
    }
复制代码

2.静态内部类。

(1)使用static修饰的内部类,叫做静态内部类。

(2)实例化:外部类名.内部名 变量=new 外部类名.内部类名();

复制代码
class Person{
     public String name="1";
     public Static int age="12";
         static class Test{
     } 
      }
      Person.Test t=new Person.Test();
复制代码

   注意与成员内部类实例化的区别。

(3)静态内部类中不能访问外部类的非静态属性和方法。

   但可以访问外部类中的静态属性和方法,使用外部类名.属性名;
     Person.age;

(4)外部类不能访问静态内部类的非静态属性和方法,但可以访问静态内部类的的静态属性和方法,外部类名.属性名。

    Test.age;

(5)【静态内部类和成员内部类的区别】

  1.声明方式和实例化方式不同。成员内部类不带static
     静态内部类实例化: Person.Test t=new Person.Test();
     成员内部类实例化: Person.Test t=p.new Test();
  2.成员内部类中不能出现静态属性和方法,但静态内部类可以。
  3.外部类和内部类的互相访问权限不同:
    ①静态内部类中不能访问外部类的非静态属性和方法。
    但可以访问外部类中的静态属性和方法,使用外部类名.属性名;
    ②成员内部类中不能出现静态属性,静态方法和静态内部类。
    但是静态常量例外。

复制代码
static class Test1{
        public static String test="111";
        
        public void say(){
            System.out.println("Test1");
        }
    }
复制代码

3.【局部内部类】(一般不用)。

(1)定义在某个类中的方法中的内部类,称为局部内部类。
(2)局部内部类是对外部完全隐藏的,只能在其作用域范围内被实例化。
(3)局部内部类可以访问外部类的属性和方法,使用外部类.this.属性名;
  Person.this.name;
(4)局部内部类:不能访问其所在方法中的变量,只能访问常量。
(5)注意:局部内部类不能使用访问修饰符修饰,因为它不属于类的成员,它属于方法中的局部变量。

复制代码
public void eat(){
//        final String name1="123";
        class Test2{
            public String name="123";
            public void test(){
                System.out.println(Person.this.name);
//                System.out.println(name1);
            }
        }
        Test2 t=new Test2();
        System.out.println(t.name);
    }
    
}
复制代码

4.匿名内部类。

new Test1(){

 };
(1)写法
(2)含义:相当于一个匿名类继承了Test1类,使用匿名内部类将直接返回当前子类的对象。
Test1 t=new Test1(){};
(3)相当于:①一个匿名内部类,继承了Test1类。
        ②匿名内部类返回一个子类对象,并付给父类引用。
    因此这一行代码用于向上转型。
(4)匿名内部类通常用于直接实例化抽象类或接口。
  Test1 t=new Test1(){
     //重写抽象类Test1中的所有的抽象方法
    //相当于一个匿名内部类,继承了Test1类,然后返回这个匿名内部类的对象。
};

复制代码
Test1 t2=new Test1(){
            public int age=12;
            public void eat(){
                System.out.println(age);
                System.out.println("eat");
            }
            public void say(){
                System.out.println("匿名重写Test1类的say方法");
            }
        };
        //向上转型,会丢失掉子类特有的属性和方法,new Test1(){}.eat();
        t2.say();
复制代码

5.使用内部类模拟多继承 。

复制代码
class A{
    public void a() {
        System.out.println("a");
    }
}
class B{
    public void b(){
        System.out.println("b");
    }
}
class C{
    class A1 extends A{
        
    }
    class B1 extends B{
        
    }
    public  void a(){
        new A1().a();//不管A类是不是抽象类都可以,如果是A则要考虑是不是抽象类
    }
    public void b(){
        new B1().b();
    }
}
复制代码
C c=new C();  //结果a,b
c.a();
c.b();

 1.【接口的定义】

(1)接口名/接口文件与类类似,接口也是使用.java文件编写。

(2)声明接口的关键字:interface,接口名命名规范与类名相同,习惯上,接口可以用I开头表示。

(3)接口的访问修饰符只能使用public和default修饰,不能使用protected和private(与外部类相同)。

(4)接口中的所有的属性,只能是公共的,静态的,常量。

   public static final int NAME=1;

  而且,public/static/final都可以省略,省略后依然是公共的,静态的常量。

  int NAME=1;

(5)接口中所有的方法必须是公共的抽象方法。

  而且,接口中的抽象方法,也可以省略public/abstract关键字。

  (public abstract) void say();

 2.【实现类实现接口】

(1)一个类实现接口使用implements关键字

(2)实现类实现一个接口,必须重写接口中的所有抽象方法,除非这个类是抽象类。

   一个类可以使用多个接口,多个接口之间,使用逗号隔开。

   class Desk implements IUsb2,3()

   一个类如果实现多个接口,必须重写所有接口中的所有方法。

(3)接口的引用可指向其实现类的对象(类似于父类引用指向子类对象)

  IUsb2 usb=new UDesk();

  因此可以使用接口实现多态。

 3.【接口继承接口】

(1)接口可以继承接口,使用extends关键字,接口继承与类的接口一样。

interface IUsb3 extends IUsb2{}

(2)接口可以多继承,多个父接口用逗号分隔,子接口继承多个父接口,将拥有所有父接口的抽象方法。

interface IUsb3 extends IUsb2,IUsb1{}

(接口不能被实例化)

4.【接口和抽象类的区别】 

 它们的本质区别:

  抽象类是一个类,接口是一个接口,子类继承抽象类,要求子类必须和父类是同一类事物,必须符合is-a关系。

  接口只是对功能的扩展。

  多个实现类实现接口时,并不要求所有的实现类是一类事物。

  接口符合like-a关系,理解为XXX具备一个XXX功能。比如人类狗类都具有吃饭功能,都具有吃饭接口,但是人类狗类的吃饭功能不能从同一个父类中继承。

(1)抽象类只能单继承,接口可以多继承,多实现。

(2)抽象类可以有自己的属性,接口中只能有静态常量。

(3)抽象类可以有非抽象方法,接口中的所有方法都必须是抽象方法(接口中的抽象方法可以省略abstract )。

(4)抽象类是一个类,接口是一种规范。

  子类继承抽象类,要求子类必须和父类是同一类事物。

  接口并不要求多个实现类是同一类事物,只能进行设计与实现的分离。

复制代码
interface IUsb2 {
/* public final static*/    int NAME=1;
//    public String name="1";//name是静态的,斜体的,接口的静态属性
    /*public abstract*/public void useUsb2();//在类中没有大括号必须加abstract修饰
}
    interface IUsb3 extends IUsb2{
        void useUsb3();
    }
     class UDesk implements IUsb2,IUsb3{

        @Override
        public void useUsb2() {
            // TODO Auto-generated method stub
            System.out.println("U盘使用useUsb2接口读取数据");
        }
        public void useUsb3() {
            // TODO Auto-generated method stub
            System.out.println("U盘使用useUsb3接口读取数据");
        }
        
    }
     class PC{
         private IUsb2 usb2 ;
         public PC(IUsb2 usb2){
             super();
             this.usb2=usb2;
         }
         public void useUsb(){
             usb2.useUsb2();
     }
     }
     public class Usb{
            public static void main(String[] args) {
                // TODO Auto-generated method stub
                
                System.out.println(IUsb2.NAME);
                IUsb2 usb=new UDesk();
                PC pc=new PC(new UDesk() );
                pc.useUsb();
            }
        }
     
复制代码

1.【java的集合框架】
 接口:
          collection                                                       map
      list                      set 
 实现类:
 ArrayList              HashSet                                   HashMap
LinkList              LinkHashSet                          LinkHashMap
Vector                   TreeSet                                   TreeMap
                                                                           HashTable

StringBuffer:安全
StringBuild:不安全
ArrayList:线程不安全
Vector:线程安全

2.【四个接口的区别】

(1)Collection:存储不唯一,无序的数据。
(2)List:存储有序的,不唯一的数据。
(3)Set:存储无序的,唯一的数据。
(4)Map:以键值对的形式存储数据,以键取值,键不能重复,值能重复。

3.【List 接口】

(1)常用方法:
 ①add()在列表的最后添加元素
 ②add(index.obj)在列表的指定位置插入元素
 ③size();返回当前列表的元素个数
 ④get(int index);返回下标为index的元素
 如果没有泛型约束,返回Object类型,需要强转,如果有泛型约束,返回约束类型,无需强转。
 ⑤clear();清除列表中的所有数据
 isEmpty();检测列表是否为空
 ⑥contains()方法,传入一个对象,检测列表中是否包含该对象。
 如果传入的是String和基本数据类型,可以直接对比。
 如果传入的是实体类对象,则默认只比对两个对象的地址,因此,需要在实体类重写equals()方法。
 ⑦indexof()传入一个对象,返回在该对象在列表中首次出现的地址。
 lastindexof()返回最后一次的地址。
 ⑧传入一个下标,或者一个对象,删除指定元素
 如果传入下标,返回被删除的元素对象,如果下标大于size(),显示越界异常。
 如果传入对象,则要求重写equals方法,返回true或false显示删除是否成功。
 ⑨set(index,obj)用新传入的对象,将指定位置的元素替换掉,返回被替换掉的元素对象。
 sublist()截取一个子列表返回list类型
 toArray()将列表转成数组,返回一个Object[]类型
 (2)ArrayList(例如新闻列表)
 是实现了长度可变的数组,在内存空间中开辟一串连续的空间,长度可以随时修改,这种存储结构再循环
 遍历和随机访问元素的速度比较快。
 (3)LinkedList
 使用链表结构存储数据,再插入和删除元素师速度比较快。
 LinkedList的特有方法:
.addfirst();开头插入元素
.addlast();结尾插入元素
 removefirst()删除第一个元素
 removelast()删除最后一个元素。返回被删除的元素
 peekfirst();检索但不删除第一个元素
 peeklast();检索但不删除最后一个元素
 pullfirst()检索删除第一个元素
 getfirst()检索但不删除第一个元素
 getlast()检索但不删除最后一个元素

复制代码
//ArrayList是实现类,实现List接口。
ArrayList list=new ArrayList();
list.add("list1");
        list.add("list2");
        list.add("list3");
        list.add("list4");
        list.add(2,"list0");
        System.out.println(list.contains("list1"));//返回true
        System.out.println(list);        //返回数组类型的
                /**
         * 使用for循环遍历列表
         */
        for(int i=0;i<list.size();i++){
            if(list.get(i) instanceof String){
                String s=(String)list.get(i);//向下转型,强转      Integer强转会出现转换异常。
                System.out.println(s);
            }else{
                Integer s=(Integer) list.get(i);
                System.out.println(s);
            }

        }//返回字符串的形式
复制代码

1.【set接口】
(1)常用方法:与list接口基本相同。
 但是由于Set接口中的元素是无序的,因此没有用下标方法。
 例如get(index),remove(index)add(index,obj)
(2)Set的特点:无序,唯一
(3)HashSet,底层是调用HashMap的相关方法,传入数据后,根据数据的hashcode进行散列运算,得到一个散列值后在进行运算,
 确定元素在序列中存储的位置。
 HashSet如何确定两个对象是否相等:
 ①先判断对象的HashCode(),如果HashCode不同,肯定不是一个对象。
 如果HashCode相同,继续判断equals方法
 ②重写equals()方法。
 所以使用HashSet存储实体对象时,必须重写对象的HashCode()和equals()两个方法;
(4)LinkedHashSet,在HashSet的基础上,新增了一个链表,
  用链表来记录HashSet元素存放的顺序,因此使用迭代器遍历时,可以按照放入的顺序一次独处。
(5)TreeSet将存入的元素进行排序,然后再进行输出,如果存入的是实体对象,那么实体类必须实现comparable接口,并重写compareTo方法。
 或者也可以在实例化TreeSet的同时,通过构造函数传入一个比较器(一个实现了comparator接口并重写了compare的方法的对象)
 //使用匿名内部类拿到一个比较器对象

 Set<Person> set=new TreeSet<Person>(new Comparator(){
 public int compare(Person p1,Person p2){
 return p1.getId()-p2.getId();
 }
 });

 //自定义一个比较类,实现Comparator接口。

Set<Person> set=new TreeSet<Person>(new Compare());
 class Compare implements Comparator(){
 //重写compare方法
}

(5)[comparable 接口和comparator的区别]
①Comparable由实体类实现,重写ComparaTo()方法
 实体类实现Comparable接口以后,TreeSet使用空参构造即可。
②Comparator需要单独一个单独比较类进行实践,重写compare方法。
 实例化TreeSet的时候,需要传入一个比较类的对象。
2.【Map】

(1)Map接口特点:以键值对的形式存储数据,以键取值键不能重复,值不能重复。

(2)Map接口的常用方法:       

  .clear() 

  replace(key,value)①put(key,value);向map的最后追加一个键值对

  map1.put("001", "小红");
②get(key);通过建,收到值
  System.out.println(map1.get("001"));
③.clear();清除Map中的所有数据
④containsValue(obj)检测是否包含指定的值
   containsKey(obj)检测是否包含指定的键,如果传入对象,需要重写equals方法。
(3)【HashTable和HashMap的区别】
 ①HashTable是线程安全的(线程同步),HashMap是线程不安全的(线程不同步)
 ②HashTable的键不能为null,HashMap的键可以为null
 ③HashMap的初始容量为16,Hashtable初始容量为11,两者的填充因子默认都是0.75。
 ④HashMap扩容时是当前容量翻倍即:capacity*2,Hashtable扩容时是容量翻倍+1即:capacity*2+1。
 ⑤HashMap继承了AbstractMap,HashTable继承Dictionary抽象类,两者均实现Map接口。
 ⑥在HashMap 中不能用get()方法来判断HashMap 中是否存在某个键,而应该用containsKey(),方法来判断。Hashtable 的键值都不能 为null,所以可以用get()方法来判断是否含有某个键。
(4)【LinkedHashMap】(无序)
 可以使用链表,记录数据放入的次序,进入让读出的顺序和放入的顺序一致,与LinkedHashSet一致
   Map<String,String> map1=new LinkedHashMap<String,String>();
(5)【TreeMap】
 根据键的顺序,进行排序后,输出。如果传入的是实体对象,必须重写比较函数,详见TreeSet
   Map<String,String> map1=new TreeMap<String,String>();

复制代码
Map<String,String> map1=new Hashtable<String,String>();
        map1.put("001", "小红");
        map1.put("002", "小王");
        map1.put("003", "小绿");
        map1.put("004", "小黄");
        map1.put(null, "小和");
        map1.replace("001", "小哈");//更改
        System.out.println(map1);
        System.out.println("****************");
        System.out.println(map1.get("001"));
        
        System.out.println("****************");
        System.out.println(map1.containsKey("001"));
        System.out.println(map1.containsValue("小绿"));//
复制代码

复制代码
Map<String,String> map1=new HashMap<String,String>();
        map1.put("001", "小红");
        map1.put("002", "小王");
        map1.put("003", "小绿");
        map1.put("004", "小黄");
        map1.put(null, "小和");
        map1.replace("001", "小哈");//更改
        System.out.println(map1);
        System.out.println("****************");
        System.out.println(map1.get("001"));
        
        System.out.println("****************");
        System.out.println(map1.containsKey("001"));
        System.out.println(map1.containsValue("小绿"));//
复制代码

(6)遍历Map的方式

①遍历Map的方式1:KeySet

复制代码
System.out.println("****************");
        Set<String> keys=map1.keySet();
        Iterator<String> it=keys.iterator();
        while(it.hasNext()){
            String key=it.next();
            System.out.println(key+"*******"+map1.get(key));
        }
复制代码

② 遍历Map的方式2:values

System.out.println("****************");
        Collection<String> values=map1.values();
        Iterator<String>it1=values.iterator();
        while(it1.hasNext()){
            System.out.println(it1.next());//可以以键取值,不能以值取键
        }

③遍历Map的方式3:entrySet

System.out.println("****************");
        Set<Map.Entry<String,String>> set2=map1.entrySet();
        /*foreach*/
        for(Map.Entry<String, String> entry:set2){
                System.out.println(entry.getKey()+"****"+entry.getValue());
        }
复制代码
/*Entry*/
        System.out.println("****************");
        Iterator<Map.Entry<String, String>> it3=set2.iterator();
        while(it3.hasNext()){
            Map.Entry<String, String>entry =it3.next();
            //entry 是Java给我们提供的一种特殊的数据类型其实是一个数据对。
            //键就是这条记录的键,使用getkey()去到
            //值就是这条记录的值,使用getValue()取到
            System.out.println(entry.getKey()+"****"+entry.getValue());
        }
复制代码

 Collections是Java中专门用于操作集合的工具类。

Collection是一个接口。

1.向集合中添加多个数据

(1)传入数据

复制代码
ArrayList<String> list = new ArrayList<String>();
        list.add("test04");
        list.add("test09");
        list.add("test03");
        list.add("test02");
        list.add("test01");
        list.add("test07");
Collections.addAll(list, "01","02","test01");
System.out.println(list);
复制代码

(2)传入对象

复制代码
List<PersonDemo> list1 = new ArrayList<PersonDemo>();
        list1.add(new PersonDemo(1,"zhangsan"));
        list1.add(new PersonDemo(5,"lisi"));
        list1.add(new PersonDemo(2,"wanger"));
        list1.add(new PersonDemo(6,"zhaowu"));
        list1.add(new PersonDemo(3,"liergou"));
Collections.addAll(list1, new PersonDemo(10,"zhngsan"),new PersonDemo(8,"wangr"));
                System.out.println(list1);
复制代码

 

2.将集合中的所有元素,全部替换为指定元素。把list里的内容替换成呵呵哒。

Collections.fill(list, "呵呵哒!");
System.out.println(list);

3.排序。

(1)sort方法: 对集合中的数据进行排序。

    Collections.sort(list1);
        System.out.println(list1);    

(2)如果集合存储的是一个实体对象,那么:

 ① 实体类实现comparable接口,并重写CompareTo方法;
 ② 在sort的第二个参数,传入比较器。 比较器需实现comparator接口,并重写compare方法。

复制代码
Collections.sort(list1, new Comparator<PersonDemo>() {
            @Override
            public int compare(PersonDemo o1, PersonDemo o2) {
                // TODO Auto-generated method stub
                return o1.getId() - o2.getId();
            }
        });
        System.out.println(list1);
复制代码

4.使用binarySearch,那么集合必须先排序。
同样,如果比较的是实体对象,依然需要通过两种方式实现比较器。

Collections.sort(list1);
System.out.println(Collections.binarySearch(list1, new PersonDemo(6,"zhaowu")));

 ②匿名内部类比较器

复制代码
System.out.println(Collections.binarySearch(list1, new PersonDemo(6,"zhaowu"),
            //匿名内部类    
        new Comparator<PersonDemo>() {
                    @Override
                    public int compare(PersonDemo o1, PersonDemo o2) {
                        // TODO Auto-generated method stub
                        return o1.getId() - o2.getId();
                    }
                }
        ));
复制代码

(4)拿到集合中最大、最小的值。

System.out.println(Collections.max(list1));
System.out.println(Collections.min(list1));

5..replaceAll(): 将列表的指定值,用新值替换。

如果是实体对象,需要在实体类中重写 equals()方法。

System.out.println(Collections.replaceAll(list1, new PersonDemo(1,"zhangsan"),
                new PersonDemo(1,"zhangsansan")));//后面返回前面,返回boolean类型
        System.out.println(list1);//返回替换后的列表

6.反转列表中的所有元素。(前后交换)

Collections.reverse(list1);
System.out.println(list1);

7.对集合的元素,进行随机排序。

Collections.shuffle(list1);
        System.out.println(list1);

8.将集合中指定的元素位置,进行交换。(把第三个和第0个交换)

Collections.swap(list1, 0, 3);
        System.out.println(list1);

 

1、 [泛型]
(1) 泛型就是“参数化类型”。 
在定义类型时,不将类型定死,而是采用泛型参数的形式进行定义。调用时传入具体的泛型参数。
2、[泛型类的特点]
 在声明类的时候,进行泛型约束,这样的类,称为泛型类。

复制代码
 class Test<T>{ // <T> 可以理解为泛型声明是的形参。可以用任何字母代替。 常用T N E
 // 在泛型类中,T就可以当做特殊的数据类型进行使用
 private T arg;
 }
 // 泛型调用时,需要将实际的数据类型进行传入。
Test<String> test1 = new Test<String>("姜浩真帅!");
Test<Integer> test2 = new Test<Integer>(123);
复制代码

(1) 泛型只在编译阶段生效。 同一个类通过不同泛型拿到的对象,使用getClass()判断是属于同一个类的。

 System.out.println(test1.getClass() == test2.getClass());
 // 取到的test1的类为 Test类,而不是Test<String>

(2)同一个类,通过不同泛型拿到的对象,相互不兼容。 不能互相赋值。

 test2 = test1; // test1与test2不兼容。

 即便,声明的泛型数据类型有父子类关系,那么用这两个数据类型声明的泛型类,还是不兼容。

Test<Integer> test2 = new Test<Integer>(123);
 Test<Number> test3 = new Test<Number>(123);
 test3 = test2; // 依然不兼容。

(3) 泛型类,在实例化的时候,可以不传入泛型。 类中的数据类型,以赋值时传入的变量类型为主。

 Test test3 = new Test(); // 实例化泛型类,没有传入泛型实参
test3.setArg("123"); // 类中的泛型变为String
 test3.setArg(456); // 类中的泛型被修改为Integer

(4) 实例化泛型时,只能传入类名,可以是系统类也可以是自定义的实体类,但不能传入基本数据类型。

Test<int> test1 = new Test<int>(); // × 

(5)泛型约束时,可以同时约束多个泛型: 

class Test1<T1,T2>{
 public T1 arg1;
 public T2 arg2;
 }
Test1<String,Integer> test4 = new Test1<String,Integer>();

(6)不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。

 test2 instanceof Test2<Integer>; // ×
 test2 instanceof Test2; //

3.[泛型通配符与上下边界]
(1) 为了解决,同一个类的多个不同泛型对象,相互不兼容的问题。 可以使用泛型通配符:?

 Test<?> test2 = new Test<String>();
// ? 表示可以兼容所有类的数据类型。

(2) 泛型通配符上边界: 使用? extends 类名,表示通配符只支持指定类及指定类的子类。

Test<? extends Number> test5 = new Test<Number>(); //
Test<? extends Number> test5 = new Test<Integer>(); //
 Test<? extends Number> test5 = new Test<String>(); // ×

(3) 泛型通配符下边界: 使用 ? super 类名,表示通配符只支持指定类及其超类。

Test<? super Integer> test6 = new Test<Integer>(); //
Test<? super Integer> test6 = new Test<Number>(); //
Test<? super Integer> test6 = new Test<String>(); // ×

4. [泛型接口]
(1) 声明泛型接口:

 interface inter<T>{
void Test(T t);
 }

(2)实现类,如果实现泛型接口,那么不能直接使用接口的泛型,需要重新声明:

class Test3<T> implements inter<T>{
@Override
 public void Test(T t) {}
 }

(3)如果实现类,不想作为泛型类。 那么,可以在实现接口时,直接给接口的泛型赋值:

 class Test3 implements inter<String>{
@Override
public void Test(String t) {}
 }

5. [泛型方法]
(1) 泛型方法可以独立于泛型类,在任何类中都可以单独使用:

复制代码
 class Test{
 public static <T> void test(T t){
 }
 } 
//调用:
 Test.test("String");
Test.test(int);
复制代码

(2) 使用泛型方法,可以实现可变参数的方法:

class Test{
 // 使用T... 表示可以接受N个 任意类型的参数; 也可以接受数组
public static <T> void test(T... t){
 }
}

 调用: Test.test("String","String2",123,true);
Test.test(new int[]{123,456,789});
(3)只有在方法中声明了<T>的方法,才叫泛型方法。
而如果在方法中,使用了类的泛型,这不能称为泛型方法。

 class Test<T>{
 // 这个不是泛型方法
 public void test(T t){}
}

 注意: 静态方法不能使用类泛型。 只能将静态方法,单独声明为泛型方法。

Math类 

 Math类位于java.lang包,不需要导包。

1.返回圆周率。

System.out.println(Math.PI);

2.返回绝对值。

System.out.println(Math.abs(-10));//绝对值,返回10

3.立方根。

System.out.println(Math.cbrt(27));//返回3

4.平方根。

System.out.println(Math.sqrt(9));//返回3

5.最大最小值。

System.out.println(Math.max(20, 19));
        System.out.println(Math.min(20, 19));

6.求a的b次方幂。

System.out.println(Math.pow(a, b));

7.floor返回一个小于指定浮点数的第一个整数,返回的是double类型,10.0。

System.out.println(Math.floor(10.5));//10.0
        System.out.println(Math.floor(-10.5));//-11.0

8.ceil返回一个大于指定浮点数的第一个整数,返回的是double类型,11.0。

System.out.println(Math.ceil(10.5));//11.0
        System.out.println(Math.ceil(-10.5));//-10.0

9.进行四舍五入,返回一个整数类型,若果传入double返回long,如果float返回int。

System.out.println(Math.round(10.5f));//11
        System.out.println(Math.round(10.3d));//10

10.保留三位小数。

public static double rounds(double num,int count){
         return Math.round(num*Math.pow(10, count))/Math.pow(10, count);
         } 
         System.out.println(rounds(10.354546,3));//diao用
System.out.println(Math.round(10.354546*Math.pow(10, 3))/Math.pow(10, 3));//10.355

11.返回最接近参数的一个整数,如果是10.5与10和11同时接近,那么返回偶数10。

System.out.println(Math.rint(10.5));//10   

12.返回【0,6)的int(左闭右开)随机一个。

System.out.println((int)(Math.random()*6));//  强转成int返回【1,6)的

13.返回ASCII码值。

System.out.println(Arrays.toString("abcdef".getBytes()));//返回数组97 98 99 100 101 102 103

14.判断是否有.java返回boolean。

System.out.println("abc.java".endsWith(".java"));

15.把0替换成o,把I替换成i。

String s="43434344250000000ooooooooooIIIIIIIIIi";
        System.out.println(s.replace("0", "o"));//4343434425oooooooooooooooooIIIIIIIIIi
        System.out.println(s.replace("I", "1"));//43434344250000000oooooooooo111111111i

 Date类

1.date空参构造: 取到当前时间。

Date date = new Date();
System.out.println(date);

2.setTime(): 传入一个长整型,重新设置date时间。

Date date = new Date();

date.setTime(1000*60*60*24);//计算机元年
System.out.println(date);

3.传入一个long类型的时间戳,取到指定时间。

date.getTime(): 取到一个时间的时间戳: 从0时区,1970年1月1日0:0:0 到当前时间的毫秒数。

Date date = new Date();
        date.setTime(1000*60*60*24);
System.out.println(date.getTime());

4.compareTo(): 前面>参数 返回 1 前面<参数 返回 -1 前面=参数 返回 0

 equals(): 比对两个时间是否相等。
   before(): 检测一个时间是不是在指定时间之前
   after(): 检测一个时间是不是在指定时间之后

System.out.println("3******************");
        System.out.println(date.before(date2));
        System.out.println(date.after(date2));
        System.out.println(date.compareTo(date2));
        System.out.println(date.equals(date2));

5.求出从95年到现在的年数。

Date date = new Date();
        System.out.println(date);//当前时间
Date date3  = new Date(95, 11, 23);
        System.out.println((date.getTime() - date3.getTime())/1000/60/60/24/365);//求出从95年到现在的年数

6.日期。

.

7.format(): 用于传入一个Date类型的参数,并返回格式化之后的字符串。

parse(): 将字符串格式的时间,转成Date类型。 要求传入的字符串格式,必须与实例化时的模式,保持完全一致
toPattern(): 返回当前格式化的模式字符串。

SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        String dateFormat = sf.format(new Date());
复制代码
Date date3 = null;
        try {//捕获异常
            date3 = sf.parse("2018年04月13日 14:09:47 星期五");
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        System.out.println(dateFormat);
        System.out.println(date3);
        System.out.println(sf.toPattern());
复制代码

Calendar 日历类

1. Calendar日历类是一个抽象类,不能直接通过new拿到对象,必须使用 Calendar.getInstance();拿到。

Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);

2.在原来的基础上减了两天。

calendar.add(Calendar.DAY_OF_MONTH, -2);
        System.out.println(calendar);

3.getTime 返回一个日期对象。

Date date4 = calendar.getTime();
        System.out.println(sf.format(date4));

4.根据calendar提供的常量,获得指定字段。

System.out.println(calendar.get(calendar.MONTH));
        System.out.println(calendar.get(calendar.DAY_OF_WEEK));

5.计算当前为星期几。

String[] arr = {"星期天","星期一","星期二","星期三","星期四","星期五","星期六"};
        int week = calendar.get(calendar.DAY_OF_WEEK)-1;
        System.out.println(arr[week]);

Random类

Random()类:取随机数
两种构造:
①空参构造
②传入一个种子数
③传入一个种子数,只要种子数相同,那么在相同次数(Random)取到的随机数肯定相同,这是伪随机数。

1.随机输出一个整数。

Random ran=new Random();//随机输出正负均可
        System.out.println(ran.nextInt());

2.nextInt()随机获得一个整数

 nextInt(n)随机获得从0到n的随机数
    nextDouble();

Random ran1=new Random(10);
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机
        System.out.println(ran1.nextInt(10));//10以内随机

3.返回毫秒数。

Date date=new Date();
        System.out.println(date.getTime()/1000/60/60/24);
        System.out.println(System.currentTimeMillis());

4.随机返回[95,103)。

Random ran=new Random();
System.out.println(ran.nextInt(8)+95);

Enum枚举类

枚举类是一种特殊的类,里面的值全部都是静态常量。
每个枚举值都相当于一个本类对象,只不过(对象的值就是对象的名)调用对象的toString方法打印的是对象名。

复制代码
enum Color{
        /**
         * 每一个枚举值都是一个本类对象。
         * 、所以声明一个枚举值,相当于执行下列代码
         * public static final BLUE=new Color();
         *  public static final PINK=new Color();
         *   public static final YELLOW=new Color();
         */
        /**
         * 在枚举类中,枚举值必须要放在第一行,其他所有代码只能放在枚举值的后面。
         * 
         * 枚举类中的构造函数,只能是私有化的,在声明枚举值时,自动调用。
         */
        BULE,RED,YELLOW,GREEN,PINK;//本类对象   
        private Color(){//构造函数在常见对象使用
            System.out.println("hahahahahah");//输出5次,枚举值的个数。                
        }
    }
    
复制代码
System.out.println(Color.BULE);

1.toString方法自动调用。

System.out.println(Color.BULE.toString());

调用对象的toString方法打印的是对象名。

返回BULE。

2.取到枚举类中所有枚举值。

Color [] colors=Color.values();
        for(Color color:colors){
            System.out.println(color.toString());
        }

3.声明一个Person枚举类型的类。

复制代码
enum Person{

        Person1 ("张",12),Person2 ("li",22),Person3 ("chen",22),Person4 ("liu",13),Person0;
        private String name;
        private int age;
        private Person(String name,int age){
            this.name=name;
            this.age=age;
        }
        private Person(){
            this.name="默认";
            this.age=0;
        }
        public String toString(){
            return name+"------"+age;
            
        }
    }
复制代码
System.out.println(Person.Person0);
        System.out.println(Person.Person1);//写toString方法

单例模式

单例模式:确保某一个类只能产生一个实例。

1.设计思路:

①将构造函数私有化,确保类外部不能使用new关键字自己创建对象。
②在类内部实例化一个对象,并通过静态方法返回。

private static Singleton sing =new Singleton();
    //如果这局部是静态的,public static Singleton getInstance()方法不能调用
    private Singleton(){//1
        System.out.println("单例模式");
    }

2. 恶汉式单例模式,在类加载的时候,就创建了一个对象。

缺点:在类加载的时候就实例化对象,提前占用系统资源
优点:线程安全。

private static Singleton sing =new Singleton();
public static Singleton getInstance(){
        return sing;
        
    }

3.懒汉式单例模式。

优点:解决了恶汉式单例,一加载就提前占用资源的问题。
 缺点:线程不安全。

复制代码
private static Singleton sing =null;
    public static  Singleton getInstance(){
        if(sing==null){
            sing =new Singleton();
        }
        return sing;
        
    }
复制代码

4.synchronized同步锁。

使用synchronized同步锁,对方法进行加锁,确保懒汉式单利可以线程安全。
将一个方法或者是代码块进行加锁,同一时间只允许一个线程访问。
 缺点:每次都需要锁住方法,每一个方法或代码块 ,效率低下。

复制代码
private static Singleton sing =null;
    public static synchronized Singleton getInstance(){//线程锁synchronized
        if(sing==null){
            sing =new Singleton();
        }
        return sing;
        
    }
复制代码

5.双重加锁的懒汉模式。

只有第一个Sing为null时,才进行线程锁,
当后续sing不为null时,就无需线程锁,可以允许多个线程同时拿走sing。

复制代码
private static Singleton sing =null;
    public static synchronized Singleton getInstance(){//锁住哪个类的对象
        if(sing==null){
            synchronized (Singleton.class) {
                if(sing==null){
                    sing =new Singleton();
                }
        }    
        }
        return sing;
        }
复制代码

6.静态内部类实现单例:

优点:解决了恶汉式提前占用资源的问题,解决了懒汉式线程不安全的问题。

复制代码
    private static class Singleton1{//不能是public外面可以直接实例化,每次都调用,不能实现单例
        private static Singleton sing =new Singleton();
    }
    public static Singleton getInstance(){
        return Singleton1.sing;
        
    }
复制代码
阅读更多
上一篇Java基础之结构
下一篇for-each的坑(Hollis)
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭