码迷,mamicode.com
首页 > 编程语言 > 详细

数组和API总结

时间:2018-05-03 19:31:49      阅读:266      评论:0      收藏:0      [点我收藏+]

标签:学海无涯   苦作舟   数组   

一:
对象数组:存储对象的一个数组
Student[] student = new Student[5] ;
int[] arr = {24,69,80,57,13} ;
Arrays:针对数组操作的工具类 (提供了一些针对数组排序和二分搜索法)
1>public static String toString(int[] a):可以将int类型的数组转换成字符串 ([元素1,元素2,元素3...])
直接用Arrays去调用
String str = Arrays.toString(arr) ;
System.out.println("str:"+str);
2>public static void sort(int[] a)对指定的 int 型数组按数字升序进行排序
Arrays.sort(arr);
String str2 = Arrays.toString(arr) ;
System.out.println("str2:"+str2);
3>public static int binarySearch(int[] a,int key):二分搜索法: 在int类型的数组中查找key元素的索引
Arrays.sort(arr);
int index = Arrays.binarySearch(arr, 57) ;
System.out.println("index:"+index);
int index2 = Arrays.binarySearch(arr, 577) ;
System.out.println("index2:"+index2);
二:
Calendar类:日历类
1.Calendar 类是一个抽象类,它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法,并为操作日历字段(例如获得下星期的日期)提供了一些方法
1> int year = rightNow.get(Calendar.YEAR) ;获取年
2>int month = rightNow.get(Calendar.MONTH) ;获取月
3>int date = rightNow.get(Calendar.DATE) ;获取日
2.抽象类的实例化
public static Calendar getInstance() :通过一个静态功能来创建日历了对象
3.Calendar中的两个常用方法:
1> public abstract void add(int field,int amount)根据日历的规则,为给定的日历字段添加或减去指定的时间量
Calendar c = Calendar.getInstance() ;
//年
int year = c.get(Calendar.YEAR) ;

//月
int month = c.get(Calendar.MONTH) ;

//日
int date = c.get(Calendar.DATE) ;

System.out.println(year+"年"+(month+1)+"月"+date+"日");
2> public final void set(int year, int month,int date)设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
c.add(Calendar.YEAR, -3);
//获取年
year = c.get(Calendar.YEAR) ;
System.out.println(year+"年"+(month+1)+"月"+date+"日");*/
//需求:5年后的10天前
c.add(Calendar.YEAR, 5);
c.add(Calendar.DATE, -10);

                                    //获取年
                                    year = c.get(Calendar.YEAR) ;
                                    date = c.get(Calendar.DATE) ;
                                    System.out.println(year+"年"+(month+1)+"月"+date+"日");

                                    System.out.println("------------------------------");
                public final void set(int year, int month,int date)设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
                                    c.set(2018, 5,20);
                                    // 获取年
                                    year = c.get(Calendar.YEAR);
                                    // 获取月
                                    month = c.get(Calendar.MONTH);
                                    // 获取日
                                    date = c.get(Calendar.DATE);
                                    System.out.println(year + "年" + (month + 1) + "月" + date + "日");

三:
1.System 类包含一些有用的类字段和方法。它不能被实例化。 

2.常用的方法:
1>public static void gc()运行垃圾回收器。
2>public static void exit(int status)终止当前正在运行的 Java 虚拟机。参数用作状态码; 一般情况,需要终止
Jvm,那么参数0
public static long currentTimeMillis()返回以毫秒为单位的当前时间

                            public class SystemDemo {

                                public static void main(String[] args) {

                                    //创建一个Person类的对象
                                    Person p = new Person("高圆圆", 27) ;
                                    System.out.println(p);

                                    //让p对象不指定堆内存了
                                    p = null ;
                                    System.gc(); //运行垃圾回收器,实质是执行的finalize()方法
                                }
                            }

3>从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束
src:原数组
dest:目标数组
srcPos :从原数组的哪个位置开始
destPos:到目标数组的哪个位置结束
length:长度
四:
java.util.Date:
类 Date 表示特定的瞬间,精确到毫秒
构造方法:
1>public Date()表示分配它的时间(精确到毫秒)。
2>public Date(long date):创建一个日期对象,指定毫秒值 (需要将long 时间毫秒值转换成Date对象)
3>public void setTime(long time):设置毫秒值
.重点:Date的日期格式和日期的文本格式:String类型 之间进行转换
Date---->String(格式化)
String-->Date(解析)
中间的转换:使用中一个中间类:DateFormat,并且DateFormat是一个抽象类,抽象意味着不能实例化,所以应该考虑用它的子类:
SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化(日期 -> 文本)、解析(文本 -> 日期)和规范化。
SimpelDateFormat的构造方法:
public SimpleDateFormat(String pattern) :构造一个SimpleDateFormat对象,根据pattern(模式:规则)
SimpleDateFormat sdf = new SimpleDateFormat("xxx年xx月xx日") ;
日期和时间模式
年: yyyy
月: MM
日: dd
时: hh
分: mm
秒: ss
实际开发中:牵扯时间的东西,经常Date--String String--Date
public class DateDemo3 {
public static void main(String[] args) throws ParseException {

Date---String:(格式化)
创建一个日期对象
Date d = new Date() ;
创建SimpleDateFormat类对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");
public final String format(Date date):格式化
String str = sdf.format(d) ;
System.out.println("str:"+str);

System.out.println("----------------------");

String:日期文本格式:---->Date:日期格式

public Date parse(String source):解析
String strDate = "2018-6-25" ;
创建SimpleDateFormat类对象
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日") ;
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
注意 :simpleDateFormat在解析文本格式的时候,里面 模式(规则)一定要和文本格式的模式一直,否则就出现PareseException
Date dd = sdf2.parse(strDate) ;
System.out.println("dd:"+dd);//dd:Mon Jun 25 00:00:00 CST 2018
}
}
4.这是Date和Stirng文本格式进行相互转换的工具类
这是一个将Date的日期格式转换成日期的文本格式
@param format 模式
@param d 需要被格式化的Date格式
@return 返回的就是日期的文本格式
public static String dateToString(String format,Date d) {
/SimpleDateFormat sdf = new SimpleDateFormat(format) ;
String s = sdf.format(d) ;
return s ;
/

                        return new SimpleDateFormat(format).format(d) ;
                    }

                        这一个将字符串文本日期格式转换Date的日期格式的功能
                        @param format  模式
                        @param s  需要被解析的日期文本格式
                        @return 返回的就Date日期格式
                        @throws ParseException 解析如果出问题了,就会有这个异常

                    public static Date stringToDate(String format,String s) throws ParseException {

                        return new SimpleDateFormat(format).parse(s) ;

        五:
        Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。  

常用的方法:
public static int abs(int a):绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static int max(int a,int b):求最大值
public static int min(int a,int b):求最小值
public static double pow(double a,double b):a的b次幂
public static double random()返回带正号的 double 值,该值大于等于 0.0 且小于 1.0
public static int round(float a):四射五入
public static double sqrt(double a):一个数的正平方根
JDK5的特性:静态导入(导入方法的级别)
public class MathDemo {
public static void main(String[] args) {

//public static int abs(int a):绝对值
System.out.println(Math.abs(-10));
System.out.println(Math.abs(10));

//public static double ceil(double a):向上取整
System.out.println(Math.ceil(12.34));

//public static double floor(double a):向下取整
System.out.println(Math.floor(12.34));

//public static int max(int a,int b):求最大值
System.out.println(Math.max(10, 20));
//方法中嵌套方法

//方法递归(方法本身调用方法的这种现象)
System.out.println(Math.max(Math.max(10, 20), 20));

//public static double pow(double a,double b):a的b次幂
System.out.println(Math.pow(2.0, 3.0));

//public static double random()返回带正号的 double 值,该值大于等于 0.0 且小于 1.0
System.out.println(Math.random());

//public static int round(float a):四射五入
System.out.println(Math.round(12.56));

// public static double sqrt(double a):一个数的正平方根
System.out.println(Math.sqrt(4));
System.out.println("---------------------------------------");

//面试题:有两个变量,让他们的值进行互换 (考官想问的是:你能否指定位^的特点)
int a = 10 ;
int b = 20 ;

//实际开发中:中间变量的方式进行互换

//位^的特点:一个数据被另一个数据位^两次,其值是它本身
/*System.out.println(a^b^b);
System.out.println(a^b^a);*/

System.out.println("a:"+a+",b:"+b);

//=号左边: a ,b,a
//=右边: a^b
a = a ^ b ; 
b = a ^ b ;//b = a^b ^ b
a = a ^ b ; 

System.out.println("a:"+a+",b:"+b);

六:
        Random:是一个可以获取随机数的类
                         public Random():无参构造方法
                         public Random(long seed) :指定long类型的数据进行构造随机数类对象 
                         public int nextInt():获取随机数,它的范围是在int类型范围之 
                         public int nextInt(int n):获取随机数,它的范围是在[0,n)之 
                        public class RandomDemo {

                            public static void main(String[] args) {

                                //创建Random类对象
                                Random r = new Random() ;

                                for(int x = 0 ; x < 10 ; x ++) {
                                    int n = r.nextInt(5) ;
                                    System.out.println(n);
                                }

            七:
            public String replaceAll(String regex,String replacement)
    使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 

@author Administrator
public class RegexDemo4 {
public static void main(String[] args) {

//定义一个字符串
String s = "hello12345World781323244454JavaEE" ;

//需求:要将数字字符被替换成*
String regex = "\\d+" ;

//定义替换的字符串
String ss = "*" ;

String result = s.replaceAll(regex, ss) ;
System.out.println("result:"+result);

    八:
关于模式和匹配器典型调用基本顺序

Pattern和Matcher
public class RegexDemo5 {
public static void main(String[] args) {
//1)将正则表达式编译成一个模式对象
// public static Pattern compile(String regex)将给定的正则表达式编译到模式中
Pattern p = Pattern.compile("a*b") ;
//2)通过模式对象,构造一个匹配器对象(Matcher对象)
// Matcher matcher(String input) :模式对象转换成匹配器对象
Matcher m = p.matcher("aaaaaab") ;
//3)匹配器对象有一个方法:machers() ; 直接对当前字符串数据进行校验,返回boolean
//public boolean matches()
boolean flag = m.matches() ;
System.out.println("flag:"+flag);

 System.out.println("-------------------------");

 //如果单纯的判断字符串是否符合正则规则,上述代码非常麻烦,
 String regex = "a*b" ;
 String str = "aaaaab" ;

 boolean flag2 = str.matches(regex) ;
 System.out.println("flag2:"+flag2);

}

                     九:
                     public String[] split(String regex) :字符串的分割功能

按照指定的格式进行分割,分割后返回的是一个字符串数组
String s1 = "aa,bb,cc" ;
String[] str = s1.split(",") ;
for (int x = 0; x < str.length; x++) {
System.out.println(str[x]);
}

System.out.println("----------------------------");

String s2 = "aa.bb.cc" ;
String[] str2 = s2.split("\\.") ;
for(int x  = 0 ; x <str2.length; x ++) {
    System.out.println(str2[x]);
}

System.out.println("----------------------------");

String s3 = "aa               bb                                      cc" ;
String[] str3 = s3.split(" +") ;
for(int x = 0 ; x <str3.length ; x ++) {
    System.out.println(str3[x]);
}
System.out.println("----------------------------");

//硬盘上的路径的形式
String s4 = "E:\\JavaSE\\Code\\day11" ;
String[] str4 = s4.split("\\\\");
for(int x = 0 ; x <str4.length ; x ++) {
    System.out.println(str4[x]);
}

十:

                                            字符

                                        x           x字符
                                        \\          反斜线字符
                                        \t          制表符 
                                        \n          换行符
                                        \r          回车符 

                                    字符类:
                                        [abc]       a、b 或 c(简单类)
                                        [^abc]      任何字符,除了 a、b 或 c(否定)
                                        [a-zA-Z]    a 到 z 或 A 到 Z,两头的字母包括在内(范围) 

                                    预定义字符类:
                                        . 任何字符      如果本身就是.     \.      qq.com  写正则表达式(\\.) 
                                        \d              数字:[0-9]                        写正则表达式 :\\d
                                        \w              单词字符:[a-zA-Z_0-9]:字母大小写,数字字符                        \\w

                                    边界匹配器:
                                        ^                行的开头 
                                        $                行的结尾 
                                        \b              单词边界 尾 (helloword?haha:world)

                                    Greedy 数量词(重点)
                                        X?              X,一次或一次也没有 
                                        X*              X,零次或多次 
                                        X+              X,一次或多次 
                                        X{n}            X字符恰好出现n次
                                        X{n,}           X字符至少出现n次
                                        X{n,m}          X字符至少出现n次,但不超过m次

十一:
对象数组:可以存储对象的数组
需求:我有5个学生,5个学生有自己的姓名,年龄,遍历当前学生数组,获取到每一个学生的信息
1)自定义类:Student name,age
2)在测试类中:创建一个数组,可以存储Stduent类型的
3)根据的提供长度,分别创建5个具体的学生对象
public class ObjectArrayDemo {
public static void main(String[] args) {
//创建一个数组,可以存储Student类型 (对象数组)
//创建数组的格式:int[] arr= new int[长度] ;
Student[] students = new Student[5] ;

//需要创建5个学生对象
Student s1 = new  Student("高圆圆", 27) ;
Student s2 = new  Student("王力宏", 30) ;
Student s3 = new  Student("唐嫣", 29) ;
Student s4 = new  Student("克劳泽",35) ;
Student s5 = new  Student("拉姆", 36) ;

//赋值
students[0] = s1 ;
students[1] = s2 ;
students[2] = s3 ;
students[3] = s4 ;
students[4] = s5 ;

//遍历学生数组
for(int x = 0 ; x < students.length ; x ++) {

// System.out.println(students[x]);
Student s = students[x] ;

    System.out.println(s.getName()+"----"+s.getAge());
}

十二:
集合的由来?

学生的面向对象语言,面向对象语言对事物的描述是通过对象体现的,那么需求需要来存储多个对象.
要存储多个对象,不能使用基本类型的变量,需要使用容器类型的变量? 学习过哪些容器变量? 数组 ,字符串缓冲区(StringBuffer)
对于字符串缓冲区来说,在内存中始终存储的是字符串,不能满足要求;数组呢,数组的长度是固定的,不符合长度编号的要求,所有Java提供了一个
Collection 集合;
面试题:????
数组和集合的区别?
1)长度区别:
数组长度固定
集合长度可变
2)内容的区别
数组可以存储同一种类型的元素
集合可以存储多种类型的元素
3)存储类型的区别
数组:可以存储基本类型,也可以存储引用类型 String[] str = {"hello","world","java",100} ; 错误的
集合:只能存储引用类型
集合:Collection:子接口有两个,两个子接口分别对应多个子实现类,多个集合数据结构不同,但是他们有共性内容,将共性内容
抽取出来,就可以集合继承体系图!
数据结构:数据的存储方式
Collection:
Collection 层次结构 中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。
JDK 不提供此接口的任何直接 实现:它提供更具体的子接口,更具体的实现类
基本功能:
添加功能:
boolean add(Object e)
删除功能:
void clear() :删除集合中所有元素(暴力删除)
boolean remove(Object o):删除集合中的指定元素
判断功能:
boolean contains(Object o):集合中是否包含指定的元素
获取功能:
int size() :获取集合中的元素数
boolean retainAll(Collection c) :交集功能: A集合对B集合取交集元素 :思考
boolean 表达的是什么意思,交集的元素是去A集合还是去B集合中
boolean removeAll(Collection c):删除一个集合中所有元素: 思考: 删除一个元素算是删除还是删除所有算是删除?
转换功能:
Object[] toArray() :将集合转换成数组
public class CollectionDemo {
public static void main(String[] args) {

//创建集合对象

// Collection c = new Collecton() ; //不能实例化
Collection c = new ArrayList() ;
System.out.println(c);
//boolean add(Object e) :添加元素
/*boolean flag = c.add("hello") ;

  add()方法的源码
 public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;   //只要添加就返回true

}

c.add("hello") ;
c.add("world") ;
c.add("java") ;
System.out.println("c:"+c) ;

//删除功能:

// c.clear();
System.out.println("remove():"+c.remove("java"));
System.out.println("c:"+c);
//boolean contains(Object o):集合中是否包含指定的元素
System.out.println("contains():"+c.contains("android"));
System.out.println("contains():"+c.contains("hello"));

System.out.println(c.size());
//boolean isEmpty() :判断集合是否为空
System.out.println(c.isEmpty());

}


5.3
一:
Colleciton的集合的高级功能:
boolean addAll(Collection c) :添加一个集合中的所有元素
boolean removeAll(Collection c):删除的高级功能(思考:删除一个算是删除还是删除所有算是删除?)
boolean containsAll(Collection c):包含所有元素算是包含,还是包含一个算是包含
交集功能:
boolean retainAll(Collection c):A集合对B集合取交集,交集的元素到底是去A集合还是去B集合中,返回值boolean
表达什么意思?
public class CollectionDemo {
public static void main(String[] args) {

//创建Collection集合1
Collection c1 = new ArrayList() ;

//添加元素
c1.add("abc1") ;
c1.add("abc2") ;
c1.add("abc3") ;
c1.add("abc4") ;

//创建第二个集合
Collection c2 = new ArrayList() ;
c2.add("abc1") ;
c2.add("abc2") ;
c2.add("abc3") ;
c2.add("abc4") ;

// c2.add("abc5") ;
// c2.add("abc6") ;
// c2.add("abc7") ;
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
System.out.println("--------------------------------");
//boolean addAll(Collection c) :添加一个集合中的所有元素
/System.out.println("addAll():"+c1.addAll(c2));/
// boolean removeAll(Collection c):删除的高级功能(思考:删除一个算是删除还是删除所有算是删除?)
//结论:删除一个算是删除...
// System.out.println("removeAll():"+c1.removeAll(c2));
//boolean containsAll(Collection c):包含所有元素算是包含,还是包含一个算是包含
//结论:包含所有算是包含
// System.out.println("containsAll():"+c1.containsAll(c2));
// boolean retainAll(Collection c):A集合对B集合取交集,交集的元素到底是去A集合还是去B集合中,
//返回值boolean表达什么意思?
/**

  • 结论:A集合对B集合取交集,交集的元素要去A集合中,boolean返回值表达的A集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false
    */
    System.out.println("retainAll():"+c1.retainAll(c2));

    System.out.println("c1:"+c1);
    System.out.println("c2:"+c2);
    }
    二:
    转换功能:Object[] toArray() :将集合转换成数组
    length():属于String类型的特有功能,可以获取字符串长度
    String str = (String) objs[x] ; //相当于:向下转型
    System.out.println(str+"----"+str.length());
    三:
    Iterator iterator() :集合的迭代器方法(获取集合的迭代器)
    集合的专有遍历方式:迭代器遍历
    Iterator :接口中有以下的方法:
    boolean hasNext() :如果有元素可以迭代,那么返回true,否则返回false
    Object next()返回迭代的下一个元素。
    存储String类型的元素
    String str = (String) obj ;
    String str = (String)(it.next()) ;
    System.out.println(str+"---"+str.length());
    !!!!! 注意:
    1)it.next(),只使用一次即可,使用多次,会出现问题(it.next(),每次使用的时候都是返回一个对象)
    2)遍历的时候使用的while循环,可不可以使用for循环呢?
    四:
    interface extends Collection{
    就可以使用Collection集合的功能
    }
    Collection有两个子接口:List Set
    迭代器:Iterator iterator() ;
    存储字符串数据,并遍历
    public class ListDemo {
    public static void main(String[] args) {
    //创建List集合对象
    List list = new ArrayList() ;

    //存储元素
    list.add("hello") ;
    list.add("world") ;
    list.add("java") ;

    //获取迭代器
    Iterator it = list.iterator() ;
    //遍历元素
    while(it.hasNext()) {
    String s = (String)it.next() ;
    System.out.println(s+"---"+s.length());
    }

    2.List集合的特点:
    有序的 (存储和取出一致),可以允许重复元素
    Set集合的特点:
    无序性(不能保证迭代的顺序,基于hashMap),并且元素不能重复
    public class ListDemo2 {
    public static void main(String[] args) {

    //创建集合对象
    List list = new ArrayList() ;

    //存储重复元素
    list.add("hello") ;
    list.add("world") ;
    list.add("hello") ;
    list.add("java") ;
    list.add("javaee") ;
    list.add("javaee") ;
    list.add("android") ;
    list.add("android") ;

    //遍历
    Iterator it = list.iterator() ;
    while(it.hasNext()) {
    String s = (String)it.next() ;
    System.out.println(s);

    3.List集合的特有功能:

    添加功能
    void add(int index,Object element):在指定位置处添加指定元素
    获取功能
    Object get(int index)返回列表中指定位置的元素。
    System.out.println("get():"+list.get(2));
    list.add(1, "javaee");
    ListIterator listIterator():列表迭代器
    删除功能:
    Object remove(int index):删除指定位置处的元素
    System.out.println("remove():"+list.remove(3));
    修改功能
    Object set(int index, Object element):用指定element元素替换掉指定位置处的元素
    System.out.println("set():"+list.set(2, "android"));
    ListIterator listIterator():列表迭代器 (List集合的专有迭代遍历:列表迭代器)
    ListIterator接口中:
    boolean hasNext() :判断是否有下一个可以迭代的元素(正向遍历)
    Object next():获取下一个元素
    boolean hasPrevious():判断是否有上一个可以迭代 元素(逆向遍历)
    Object previous():返回上一个元素
    逆向迭代(遍历),单独使用没意义,前提,要先正向遍历
    五:
    List集合类的子实现类的特点
    List集合有三个子实现类:
    ArrayList
    底层数据结构式数组结构,查询块,增删慢
    从内存角度考虑:线程不安全的,不同步的,执行效率高

            多线程:synchronized :同步的意思     解决线程安全问题
                    sychronized(锁对象){   同步代码 
                            共享数据;   
                    }
    
            解决线程安全问题,通过同步可以解决,但是效率低了...
    
    LinkedList
            :底层数据结构式链表结构,查询慢,增删块
            从内存角度考虑:线程不安全,不同步,执行效率高
    
    Vector:
            这是一个线程安全的类,
            底层数据结构是数组:查询快,增删慢
            线程安全的,同步,执行效率低!

数组和API总结

标签:学海无涯   苦作舟   数组   

原文地址:http://blog.51cto.com/13678296/2112281

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!