Java学习笔记(Javase毕向东版视频)六 常用API对象二
浏览数：16 /
时间：2015年06月08日
1、基本数据类型对象包装类:见下图
1 public class Test { 2 public static void main(String[] args){ 3 Demo(); 4 toStringDemo(); 5 jdkDemo(); 6 } 7 8 private static void jdkDemo() { 9 //注意:在1.5之后的版本中可以使用下面的形式 简化书写 ,这是版本升级的一个方面 10 Integer i=3; //自动装箱,jdk是Integer i = Integer.valueOf(3); 11 i=i+3; //自动拆箱, 12 /*注意:和用new生成对象的小区别是, 13 * 简写书写时如果数值在一个字节以内(即<128)时,重复生成不产生新空间 14 */ 15 Integer a=127; 16 Integer b=127; 17 System.out.println(a==b); 18 System.out.println(a.equals(b)); 19 Integer c=128; 20 Integer d=128; 21 System.out.println(c==d); 22 System.out.println(c.equals(d)); 23 } 24 25 static void Demo(){ 26 /*1、获取对象包装器类,以Integer为例: 27 * 最简单的是使用new,可以传入一个本类的基本数据和""包含的本类基本数据 28 * 注意:如果""中包含的不是本类基本数据会抛出一个运行时异常 29 */ 30 Integer a=new Integer(3); 31 Integer b=new Integer("3"); 32 33 //2、也可以使用静态方法valueOf()来获取对象包装类对象实例 34 // Integer c=Integer.valueOf("3"); 35 // Integer d=Integer.valueOf("3", 10); //第二个参数指定进制 36 // Integer e=Integer.valueOf(3); //这是1.5版本后新增的 37 38 //3、当然也可以将包装类对象转换为基本类型,注意不仅可以是本类基本类型,还可以是其他基本类型(但不是所有的) 39 // int f=a.intValue(); 40 // byte g=a.byteValue(); 41 42 //4、基本类型封装成对象之后的比较 43 System.out.println(a==b); //比较地址 44 System.out.println(a.equals(b)); //比较是否相等 45 System.out.println(a.compareTo(b)); //比较大小(根据字典顺序) 46 } 47 48 private static void toStringDemo() { 49 //对象包装类的一个主要作用就是将基本数据类型和String类型互换 50 //1、基本类型转换为String类型 51 Integer i=new Integer(60); 52 //使用静态方法 53 System.out.println(Integer.toString(i)); 54 System.out.println(Integer.toString(i, 16)); 55 // 56 System.out.println(i.toString()); 57 //Integer类还可以选择特定的进制进行转换,如2进制,8进制,16进制。是静态方法,内部调用toSting() 58 System.out.println(Integer.toBinaryString(i)); 59 60 //2、String转换为基本类型 61 String s="60"; 62 System.out.println(Integer.parseInt(s)); 63 //！！！下面的进制是将字符串当做该进制的数进行解析,返回一个10进制的数 64 s="3c"; 65 System.out.println(Integer.parseInt(s,16)); 66 } 67 }
参考:自动装箱
2、集合类:
！！！集合框架图：
Collection接口和List接口的方法:
1 import java.util.ArrayList; 2 import java.util.Iterator; 3 import java.util.ListIterator; 4 5 public class CollectionInterface { 6 public static void main(String[] args){ 7 Demo(); 8 iteratorDemo(); 9 listDemo(); 10 ListIteratorDemo(); 11 } 12 13 public static void Demo() { 14 ArrayList a1=new ArrayList(); 15 ArrayList a2=new ArrayList(); 16 a1.add("asd1"); 17 a1.add("asd2"); 18 a2.add("asd2"); 19 a2.add("asd3"); 20 System.out.println("a1="+a1); 21 System.out.println("a2="+a2); 22 //注意:addAll()会将指定集合所有对象都添加,即使用重复的也会添加 23 a1.addAll(a2); 24 System.out.println("a1="+a1); 25 //注意:removeAll()会将指定集合所有对象都删除,！！！两者中共有的也会删除 26 a1.removeAll(a2); 27 System.out.println("a1="+a1); 28 //retainAll()和removeAll()相反,会将指定集合所有对象都保存,而把其他全删除 29 } 30 31 public static void iteratorDemo() { 32 ArrayList a1=new ArrayList(); 33 a1.add("asd1"); 34 a1.add("asd2"); 35 a1.add("asd3"); 36 a1.add("asd4"); 37 /*迭代器是集合容器用来取元素的方法,不同集合有不同的取法,所以具体的迭代器依赖于具体容器, 38 * ！！！Java只提供一个接口,每一个容器都需要将其作为 内部类 实现用以获取元素即可 39 * 使用iterator()获取一个迭代器,并用该迭代器获取集合中对象, 40 * 迭代器Iterator接口有三个方法: 41 * 1、hasNext():检测是否有下一个元素,因为获取方法不检测是否超过集合容量,超过会报错 42 * 2、next():获取下一个元素 43 * 3、remove():删除元素 44 */ 45 // Iterator i=a1.iterator(); 46 // while(i.hasNext()){ 47 // System.out.println(i.next()); 48 // } 49 // ！！！使用while循环的缺点是在循环遍历后,该迭代器已经不能去除任何值,但仍可以使用,浪费空间,可改为for循环 50 for(Iterator i=a1.iterator();i.hasNext();){ 51 System.out.println(i.next()); 52 } 53 } 54 55 private static void listDemo() { 56 //List集合的特有方法:由于List集合中元素有角标,！！！所以特殊方法就是利用角标来进行增删改查 57 //注意 改 的方法在Collection中没有 58 ArrayList a=new ArrayList(); 59 //普通添加和指定位置添加 60 a.add("asd2"); 61 System.out.println("a="+a); 62 a.add(0,"asd3"); 63 System.out.println("a="+a); 64 //修改指定位置元素,set()返回值是原来该位置的元素 65 System.out.println("被删除的元素是:"+a.set(0,"asd1")); 66 System.out.println("a="+a); 67 } 68 69 private static void ListIteratorDemo() { 70 ArrayList a1=new ArrayList(); 71 a1.add("asd1"); 72 a1.add("asd2"); 73 a1.add("asd3"); 74 // Iterator i=a1.iterator(); 75 // while(i.hasNext()){ 76 // Object obj=i.next(); 77 // if(obj=="asd3"){ 78 // a1.add("asd5"); 79 // }else{ 80 // System.out.println(i.next()); 81 // } 82 // } 83 /*在使用迭代器Iterator接口时,!!!不能同时进行增/删/改的操作, 84 * 会报ConcurrentModificationException异常。 85 * 可以使用子接口ListIterator接口代替,！！！由名字可以看出只在List集合中使用 86 * ListIterator还允许逆向遍历List,使用hasPrevious() 87 */ 88 ListIterator i=a1.listIterator(); 89 while(i.hasNext()){ 90 Object obj=i.next(); 91 if(obj=="asd3"){ 92 i.add("asd4"); 93 }else{ 94 System.out.println(i.next()); 95 } 96 } 97 System.out.println("a1="+a1); 98 } 99 }
下面是List接口的常用子类:
1 public class Person implements Comparable<Person>{ 2 private int age; 3 public Person(int age, String name) { 4 super(); 5 this.age = age; 6 this.name = name; 7 } 8 private String name; 9 public int getAge() { 10 return age; 11 } 12 public void setAge(int age) { 13 this.age = age; 14 } 15 public String getName() { 16 return name; 17 } 18 public void setName(String name) { 19 this.name = name; 20 } 21 //这里的重写是为了HastSet练习使用 22 @Override 23 public int hashCode() { 24 return name.hashCode()+age; 25 } 26 @Override 27 public boolean equals(Object obj) { 28 Person p=(Person)obj; 29 return this.name.equals(p.name)&&(this.age==p.age); 30 } 31 //这里的 重写是为了TreeSet练习使用 32 @Override 33 public int compareTo(Person o) { 34 //注意适用泛型后不需要在进行类型强转 35 int count=0; 36 if(o instanceof Person){ 37 Person p=(Person)o; 38 // if(this.age>p.age){ 39 // return 1; 40 // }else if(this.age<p.age){ 41 // return -1; 42 // }else{ 43 // return this.name.compareTo(p.name); 44 // } 45 return count=this.age-p.age==0?this.name.compareTo(p.name):count; 46 } 47 return 0; 48 } 49 50 }
1 import java.util.ArrayList; 2 import java.util.Iterator; 3 import java.util.LinkedList; 4 import com.lll.cn.Person; 5 6 public class ListSubClassDemo { 7 public static void main(String[] args){ 8 VectorDemo(); 9 LinkedListDemo(); 10 LinkedListTest(); 11 ArrayListDemo(); 12 } 13 14 public static void VectorDemo() { 15 //该类由于效率低下,和Enumeration一起不推荐使用 16 } 17 18 public static void LinkedListDemo() { 19 /*LinkedList是链表结构,所以特殊方法是和第一个元素/最后一个元素相关 20 * 如在第一个/最后一个位置添加元素,删除元素,获取元素等 21 * ！！！注意有些方法仅仅获取,有些是移除并返回 22 * 注意: 23 */ 24 LinkedList<String> l=new LinkedList<String>(); 25 l.add("asd2"); 26 l.add("asd3"); 27 l.addFirst("asd1"); 28 System.out.println("最后一个元素是"+l.getLast()); 29 while(!l.isEmpty()){ 30 System.out.println(l.removeFirst()); 31 } 32 System.out.println(l); 33 } 34 35 public static void LinkedListTest() { 36 /*使用LinkedList模拟堆栈和队列两种数据结构 37 * 堆栈:先进后出First In Last Out -->FILO 38 * 队列:先进先出First In First Out -->FIFO 39 */ 40 StackDemo q=new StackDemo(); 41 q.myAdd("asd9"); 42 q.myAdd("asd2"); 43 q.myAdd("asd3"); 44 q.myAdd("asd4"); 45 System.out.println(q.myRemove()); 46 } 47 48 private static void ArrayListDemo() { 49 //ArrayList集合是最常用的的集合,并且通常用于存储自定义对象 50 ArrayList<Person> a=new ArrayList<Person>(); 51 a.add(new Person(11,"asd1")); 52 a.add(new Person(12,"asd2")); 53 a.add(new Person(13,"asd3")); 54 a.add(new Person(14,"asd4")); 55 /*！！！注意在使用集合存储数据时的易错点 56 * 1、所有自定义类型都会转换为Object类型,所以在使用时应该进行强制转换 57 * 2、在一个循环中使用next()时应该小心,因为每次next()都会将指针向下移动而不再指向刚才对象 58 * 下面就是错误示例 59 */ 60 for (Iterator<Person> i = a.iterator(); i.hasNext();) { 61 //System.out.println(i.next().getName()+i.next().getAge()); 62 Person p=(Person) i.next(); 63 System.out.println(p.getName()+":"+p.getAge()); 64 65 } 66 } 67 } 68 class QueueDemo{ 69 private LinkedList<Person> l=null; 70 QueueDemo(){ 71 l=new LinkedList<Person>(); 72 } 73 public void myAdd(Person obj){ 74 l.add(obj); 75 } 76 public Object myRemove(){ 77 return l.removeFirst(); 78 } 79 } 80 class StackDemo{ 81 private LinkedList<String> l=null; 82 StackDemo(){ 83 l=new LinkedList<String>(); 84 } 85 public void myAdd(String obj){ 86 l.add(obj); 87 } 88 public Object myRemove(){ 89 return l.removeLast(); 90 } 91 }
迭代器接口(Iterator):用于获取容器中的元素,是枚举类(Enumeration)的改进版,增加了删除功能并简化了书写。枚举类是伴随着Vector类的出现而出现的,也伴随着该类的改进(使用ArrayList代替)而被改进(使用Iterator代替)
链表和数组:
LinkedList特有方法:
Set常用子类:
1 import java.util.HashSet; 2 import java.util.Iterator; 3 import java.util.LinkedHashSet; 4 import java.util.TreeSet; 5 6 import com.lll.cn.Person; 7 8 public class SetSubDemo { 9 public static void main(String[] args){ 10 HashSetDemo(); 11 HastSetTest(); 12 TreeSetDemo(); 13 } 14 15 public static void HashSetDemo() { 16 /*HashSet的底层结构仍是数组,但是有所改进: 17 * 即存入数据时是根据哈希算法获取该数据的地址值,然后将其存入该地址 18 * 特点: 19 * 1、不允许存入相同元素, 20 * 2、如果计算出两个相同地址值,会将后者进行修改后存储 21 * 3、获取时计算地址值,如果该位置有元素且 22 * ！！！注意确定对象地址值的哈希算法就是对象内部的hashCode(),如果没有则使用继承自Object的 23 * 所以要使用HashSet来存储数据,并保证其中的值唯一,应该修改hashCode()和equals() 24 * 25 * ！！！在集合中对一个元素进行操作(例如remove,contains),首要的是判断在集合中是否有该对象, 26 * 通常依靠的是equals()和hashCode()。所以使用自定义对象时,应该对这两个方法进行重写 27 */ 28 } 29 30 public static void HastSetTest() { 31 HashSet<Person> hs=new HashSet<Person>(); 32 //如果自定义对象也要达到确保唯一性的要求,就要覆写hashCode()和equals(),原因见上 33 hs.add(new Person(11,"asd1")); 34 hs.add(new Person(12,"asd2")); 35 hs.add(new Person(13,"asd3")); 36 hs.add(new Person(14,"asd4")); 37 hs.add(new Person(11,"asd1")); 38 for (Iterator<Person> i = hs.iterator(); i.hasNext();) { 39 Person obj = (Person) i.next(); 40 System.out.println(obj.getName()+":"+obj.getAge()); 41 } 42 //HashSet还有一个子类LinkedHashSet,具有LinkedList和HashSet双重特性:即有序又唯一 43 LinkedHashSet<Person> lhs=new LinkedHashSet<Person>(); 44 lhs.add(new Person(11,"asd1")); 45 lhs.add(new Person(12,"asd2")); 46 lhs.add(new Person(13,"asd3")); 47 lhs.add(new Person(14,"asd4")); 48 lhs.add(new Person(11,"asd1")); 49 for (Iterator<Person> i = lhs.iterator(); i.hasNext();) { 50 Person obj = (Person) i.next(); 51 System.out.println(obj.getName()+":"+obj.getAge()); 52 } 53 } 54 55 public static void TreeSetDemo() { 56 /*TreeSet集合会对存入的对象进行比较然后进行存放,比较的过程可以用以下两种方式实现 57 * 1、使对象实现Comparable借口,重写compareTo(),称为自然排序方法 58 * 2、使集合具备排序功能,就是向TreeSet中传入一个实现了Comparator接口的类的对象实例 59 */ 60 TreeSet<Person> ts=new TreeSet<Person>(); 61 ts.add(new Person(21,"asd1")); 62 ts.add(new Person(22,"asd2")); 63 ts.add(new Person(22,"asd3")); 64 ts.add(new Person(24,"asd4")); 65 for (Iterator<Person> i = ts.iterator(); i.hasNext();) { 66 Person p = (Person) i.next(); 67 System.out.println(p.getName()+":"+p.getAge()); 68 } 69 TreeSet<Person> ts2=new TreeSet<Person>(new ComparatorByName()); 70 ts2.add(new Person(21,"asd1")); 71 ts2.add(new Person(22,"asd2")); 72 ts2.add(new Person(22,"asd3")); 73 ts2.add(new Person(24,"asd1")); 74 for (Iterator<Person> i = ts2.iterator(); i.hasNext();) { 75 Person p = (Person) i.next(); 76 System.out.println(p.getName()+":"+p.getAge()); 77 } 78 } 79 }
1 import java.util.Comparator; 2 3 import com.lll.cn.Person; 4 5 public class ComparatorByName implements Comparator<Person> 6 { 7 //这个类是外部类,用于集合中元素的比较 8 @Override 9 public int compare(Person p1, Person p2) 10 { 11 int comp=0; 12 13 return (comp=p1.getName().compareTo(p2.getName()))!=0?comp:p1.getAge()-p2.getAge(); 14 //return 1; 15 } 16 }
哈希如何判断元素相等:
二叉树:
郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。
