java基础第十三篇之Collection

常见的几种数据结构: * 1.堆栈:先进后出 * 2.队列:先进先出 * 3.数组:查找快,增删慢 * 4.链表:查找慢,增删快 import java.util.LinkedList;

/* * java集合的根接口 Collection * 共性的方法:增删改查 * 增:add(E e);//addAll(Collection<? extends E> c) * 删:remove(Object obj); * 改:无 * 查:size() * 其他:toArray();clear();isEmpty(); * * 分为两个子接口:List<E>,Set<E> * 1.List:接口,有实现类:ArrayList<E>,LinkedList<E>,Vector<E> * 特点:a.有序的,(这里的有序 不是指123,或者abc这种自然顺序,指的存和取的顺序一致) * b.有索引(有下标) * c.元素可重复 * List接口中定义方法:增删改查 * 增加: add(E e);add(int index,E e);//在指定下标处增加一个元素 * 删除: remove(Object obj); remove(int index);//删除指定下标元素 * 修改: set(int index,E e);//把指定下标元素改为新的元素 * 查询: get(int index);//获取指定下标的元素 * List接口下各种实现类的数据结构特点: * ArrayList: 内部采用动态数组结构:查找快,增删慢 * LinkedList: 内部采用双向链表结构:查找慢,增删快 * Vector: 内部采用数组结构:查找快,增删慢 * 说明:Vector是从JDK1.0 开始有的 * Collection集合根接口从JDK1.2开始的 * =============================================== * 实际上ArrayList和Vector中基本没有特有的方法,这些实现类的方法基本上都是List中的方法 * LinkedList特有的方法: * 第一组: * addFirst(E e),addLast(E e); * 第二组: * public E removeFirst();//返回并删除首元素 * public E removeLast(); * 第三组: * public E getFirst();//返回首元素 * public E getLast(); * 第四组: * public E pop();//出栈,弹栈,就是从集合中删除元素(哪一个:集合首个元素,类似于 removeFirst) * public void push(E e);//压栈,就是向集合添加一个元素(添加到集合的第一个,类似于add,addFirst) * * * 2.Set:接口,有实现类,HashSet,LinkedHashSet,TreeSet * 特点:a.元素不重复 * b.无索引(无下标) * c.无序(有例外,LinkedHashSet,TreeSet) * Set接口中定义方法:增删改查(特别好记,Set接口中没有特有方法完全和Collection接口一模一样) * * Set接口下各种实现类的数据结构特点: * HashSet: 内部采用哈希表结构 * 特点:查找较快,增删也较快 * LinkedHashSet: 内部采用 链表结构+哈希表结构 组合结构 * 特点:查找较快,增删也较快 * HashSet和LinkedHashSet特有的方法:无 * 全部都是和Set接口中一样,和Collection接口中一样 */ public class LinkedListDemo01 {

public static void main(String[] args) { // TODO Auto-generated method stub demo01(); } /* * LinkedList特有的方法 */ public static void demo01(){ //创建一个对象 LinkedList<String> names = new LinkedList<String>(); names.add("jack"); names.add("rose"); names.add("lilei"); names.add("rose"); //添加 // names.addFirst("hanmeimei"); // names.addLast("Tom"); //获取(仅仅取出元素,但是不删除) // String s1 = names.getFirst(); // System.out.println(s1); // String s2 = names.getLast(); // System.out.println(s2); //删除元素(不仅取出元素,而且会在集合中删除) // String s1 = names.removeFirst(); // System.out.println(s1); // String s2 = names.removeLast(); // System.out.println(s2); //pop 出栈方法 // String s1 = names.pop(); // System.out.println(s1); // String s2 = names.pop(); // System.out.println(s2); //push 入栈方法 names.push("Tom"); names.push("Jirui"); System.out.println(names); } }

* * HashSet 判断元素是否重复是根据两个条件 * * 1.看新元素的哈希值 和 所有旧元素是否相同,如果不相同那么不重复,存储 * * 2.如果哈希值相同了,调用equals方法,拿新元素和哈希值相同的那个旧元素,返回值true,那么判断重复元素,不存储 * 返回值false 判断不重复 可以存储 * * * 哈希表:底层是 数组结构+链表结构 特点:查找较快,增删较快 哈希表又称散列表，是一种能将关键字映射成存储地址的记录存储技术。 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录， 以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。Hash就是找到一种数据内容和数据存放地址之间的映射关系。 * 对象的哈希值: * 实际上java中所有的对象 都有一个字符串表示:toString(),默认:包名.类名@哈希值 * 实际上java中所有的对象 都有一个数字的表示:hashCode();//返回的就是一个数字,就是我们说对象的哈希值 * * * 字符串的哈希值: * 字符串类的哈希值 自己重写了hashCode,计算哈希值只跟内容有关系,所有内容相同的字符串,哈希值必定相同 * 内容不同的字符串,哈希值还有可能相同 * * * */ public class StringHashDemo01 {

public static void main(String[] args) { // TODO Auto-generated method stub String s1 = new String("重地"); String s2 = new String("通话"); int h1 = s1.hashCode(); int h2 = s2.hashCode(); //System.out.println(h1==h2); //哈希值是根据地址值计算的,如果String类没有重写hashCode那么算出来的哈希值应该是不一样 //因为String类重写了 hashCode,所以不同的地址和hash值的计算已经没有关系 //System.out.println(s1==s2);//false System.out.println(h1);//96354 System.out.println(h2); // System.out.println(s1); // System.out.println(s2); //我们看了String类的hashCode方法,字符串的哈希值,只跟内容有关系 //可能不可能出现 字符串的内容不同 但是哈希值相同 //比如:"abc"和"acD" //比如: "重地"和 "通话" } /* * 对象的哈希值 */ public static void demo01(){ //创建Person对象 Person p1 = new Person(); int hash = p1.hashCode(); //hash就是p1的哈希值 System.out.println(hash); System.out.println(p1.toString()); //我们骗了19天,打印对象默认打印出来的不是地址值 是hash值 //哈希值是根据地址值算出来的,怎么算的我们不知道 //实际上 由地址值 计算哈希值 由一个算法计算 散列算法---哈希算法 //在我们java程序中能不能打印出对象 真正的地址值(不能) //但是地址值 是真正存在的 对象中存储的就是真正的地址值 但是打印的时候打印出来是哈希值 Person p2 = new Person(); int hash2 = p2.hashCode(); System.out.println(hash2); //不同的对象 地址值肯定不一样,但是哈希值有可能一样吗? }

}

/* * 使用HashSet存储自定义的元素:存储Student对象 * * 我们要求:如果一个学生对象的年龄和姓名都相同,我们不让HashSet存储它 * * 以后写一个类: * 1.封装: * 2.构造(全参和无参) * 3.toString(方便输出对象) * 如果这个类还要存储到集合中最好 * 4.hashCode * 5.euqals * */ public class Student { private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Student() { super(); // TODO Auto-generated constructor stub } public Student(int age, String name) { super(); this.age = age; this.name = name; } @Override public String toString() { return "Student [age=" + age + ", name=" + name + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; }

//自己重写hachCode // 20 abc // 20 acD // 19 acE // @Override // public int hashCode() { // //我们目的,让年龄相同并且名字相同的对象返回的哈希值也相同 // return this.age * 31 + this.name.hashCode()*49; // } //Eclipse自动生成的hashCode //自己重写equals方法,让年龄相同,名字相同两个对象调用equals返回值是true // @Override // public boolean equals(Object obj) { // // TODO Auto-generated method stub // Student s = (Student)obj; // if(this.age != s.getAge()){ // return false; // } // if(!this.name.equals(s.getName())){ // return false; // } // return true; // } //Eclipse自动生成的equals方法 }

/* * LinkedHashSet和HashSet的不同点: * HashSet是无序的 * LinkedHashSet是有序的 * * contains方法和add方法的原理 * * 1.如果是ArrayList存储自定义元素 ,那么这个自定义类型 只要重写 equals * * 2.如果是HashSet存储自定义元素,那么这个自定义类型 必须重写两个 hashCode,equals * */

/* * Collection<E>接口: * add(E e) remove(Object o),size(),toArray();isEmpty();contains() * 迭代器 * 获取迭代器: Iterator<E> it = 集合对象.iterator(); * 使用迭代器: * it.hasNext(); it.next(); * * List<E>和Set<E> * 能够说出List集合特点:有序,索引和重复 * 能够说出Set集合的特点:无索引,不重复,无序的(但是LinkedHashSet,TreeSet是有序的) * * 使用List存储的数据结构:ArrayList是数组结构 LinkedList是链表结构 * * 说出哈希表的特点:数组结构+链表结构: 查找较快,增删较快 * * 使用HashSet集合存储自定义元素(保证元素的内容相同不能存储) * 快捷键:alt+shift+s,h * * 说出判断集合元素唯一的原理 * Collection中有contains(Object o); * ArrayList中 只调用equals比较 * HashSet中 调用hashCode 和 equals * * 冒泡排序:把一个数组里面的内容 按照从小到大 或者从大到小

*/ public class BubbleDemo { public static void main(String[] args) { int[] nums = {7,65,10,532,47,45,234,84,3}; int len = nums.length; //外层控制趟数 for (int i = 0; i < len-1; i++) { //里控制次数 for(int j = 0;j < len-1-i;j++){ //nums[j] 和 nums[j+1] if(nums[j] > nums[j+1]){ int temp = nums[j]; nums[j] = nums[j+1]; nums[j+1] = temp; } } } for (int i = 0; i < nums.length; i++) { System.out.println(nums[i]); } } }

冒泡排序优化版:

package com.baidu_01;

import java.util.Arrays;

public class Test3 { public static void main(String[] args) { //int[] arr = {1,8,5,3,7,6}; int[] arr = {1,2,3,4,5,6}; boolean b = true ; for(int i = 0; i < arr.length-1 ; i++) { //b = true; for(int j = 0; j < arr.length - 1 -i;j++) { if(arr[j] > arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; b = false; } } if(b) { System.out.println("遍历了一次"); break; } } System.out.println(Arrays.toString(arr)); } }

3.TreeSet类

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。

TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0。向TreeSet中添加的应该是同一个类的对象，且最好是不可变对象。

1.自然排序

自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。

Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。

obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。

如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0

2.定制排序

自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法，该方法用于比较o1和o2的大小：如果该方法返回正整数，则表示o1大于o2 ；如果方法返回0，则表示o1等于o2，如果该方法返回负整数，则表示o1小于o2。 Java静态代码块、构造代码块、构造方法的执行顺序 的执行顺序

静态代码优先于非静态的代码，是因为被static修饰的成员都是类成员，会随着JVM加载类的时候加载而执行，而没有被static修饰的成员也被称为实例成员，需要创建对象才会随之加载到堆内存。所以静态的会优先非静态的。 执行构造器（构造方法）的时候，在执行方法体之前存在隐式三步： 1，super语句，可能出现以下三种情况： 1）构造方法体的第一行是this语句，则不会执行隐式三步， 2）构造方法体的第一行是super语句，则调用相应的父类的构造方法， 3）构造方法体的第一行既不是this语句也不是super语句，则隐式调用super()，即其父类的默认构造方法，这也是为什么一个父类通常要提供默认构造方法的原因； 2，初始化非静态变量； 3，构造代码块。 由此可知，构造代码块优先于构造方法的方法体，但是this关键字跟super关键字不能同时出现，而且只能在代码的第一行。如果出现了this关键字，隐式三步就不会执行。 例如，分析下面的代码及执行结果，已经用注释标出了执行步骤Step 1–Step 7。 也就是说，当递归调用多个构造方法的时候，构造代码块只会在最后的（也即方法体第一行不是this语句的）那个构造方法执行之前执行！

public class Test { public static int a = 0;

static {// Step 1 a = 10; System.out.println("静态代码块在执行a=" + a); }

{// Step 4 a = 8; System.out.println("非静态代码块（构造代码块）在执行a=" + a); }

public Test() { this("调用带参构造方法1，a=" + a); // Step 2 System.out.println("无参构造方法在执行a=" + a);// Step 7 }

public Test(String n) { this(n, "调用带参构造方法2，a=" + a); // Step 3 System.out.println("带参构造方法1在执行a=" + a); // Step 6 }

public Test(String s1, String s2) { System.out.println(s1 + "；" + s2);// Step 5 }

public static void main(String[] args) { Test t = null;// JVM加载Test类，静态代码块执行 System.out.println("下面new一个Test实例："); t = new Test(); } public boolean contains(Object c) : 判断是否包含元素 public boolean isEmpty() : 判断是否为空 public int size() : 获取集合长度 Collection中主要方法: boolean add(E e) : 添加元素 boolean remove(Object o) : 删除元素 void clear() : 清空集合 boolean contains(Object o1) : 判断是否包含某元素 boolean isEmpty () : 判断是否为空 int size() : 获取集合长度 } 1 33 执行结果：

静态代码块在执行a=10 下面new一个Test实例： 非静态代码块（构造代码块）在执行a=8 调用带参构造方法1，a=10；调用带参构造方法2，a=10 带参构造方法1在执行a=8 无参构造方法在执行a=8 */

/*

Arrays : 查API static void sort(Object[] obj) : 对传进来的基本类型数组进行排序 static void toString(Objec[] a) : 对传入的数组内容以字符串的形式表现出来. 方法重写:字符类出现了一摸一样的方法(注意:返回值类型可以是子父类)

Override和Overload的区别?Overload能改变返回值类型吗? overload可以改变返回值类型,只看参数列表.

方法重载:本类中出现的方法名一样,参数列表不同的方法,与返回值类型无关.

子类对象调用方法的时候: 先找子类本身,再找父类. final关键字修饰局部变量:

1.基本类型,是指不能被改变. 2.引用类型,是地址值不能被改变,对象中的属性可以改变

final修饰变量的初始化时: 1.显示初始化; 2.在对象构造完毕前即可

面试:

要求使用已知的变量,在控制台输出30,20,10

class Outer { public int num = 10; class Inner { public int num = 20; public void show () { int num = 30; syso(); syso(); syso(); } } } class InnerClassTest { public static void main(String[] args ) { Outer.Inner oi = new Outer().new Inner(); oi.show(); } }

package , import , class 顺序为:package - import - class 按照这个顺序执行

代码块的概述:在java中,使用{}括起来的代码被称为代码块.

A.代码块分为:局部代码块,构造代码块,静态代码块,同步代码块

代码块应用:

a.局部代码块:在方法中出现;限定变量声明周期,及早释放,提高内存利用率.

b.构造代码块(初始化块) : 在类中方法外出现;多个构造方法中相同的代码块放到一起,每次调用构造都指向,并且在构造方法前指向

c.静态代码块:在类中方法外出现,并加上static 修饰;用于给类进行初始化,在加载的时候就指向,并且只执行一次. 一般用于加载驱动. 多态调用方法这么执行: 成员变量:编译看左边(父类),运行看左边(父类); 成员方法:编译看左边(父类),运行看右边(子类).动态绑定 静态方法:编译看左边(父类),运行看左边(父类); (静态和类相关,算不上重写,所以,访问换是左边的) 只有非静态方法的成员方法,编译看左边,运行看右边. 内部类访问特点: 外部类访问内部类必须创建对象. 外部类名.内部类名 对象名 = 外部类对象.内部类对象

静态成员内部类:

static :成员内部类被静态修饰后的访问方式是: 外部类名.内部类名 对象名 = 外部类.内部类对象;

面试: class A { public void show () { show2(); } public void show2() { syso("我"); } } class B extends A{ show(){ show2(); } show 2 (){ syso("爱") } } class c extends B{ show(){ show2(); } show 2 (){ syso("你") } } public class Test { main { A a = new B(); a.show(); B b = new C(); b.show(); } }

面试题: 一个抽象类如果没有抽象方法,可不可以订阅为抽象类,?有什么意思? 可以,这么做只有一个目的,就是不让其他类创建本类对象,交给子类完成.

class Test { public static void main(String[] stgs ) { //Outer.method().show(); Inter i = Outer.method(); i.show(); } } //按照要求补齐代码 interface Inter { void show(); } class Outer { public static Inter method() { return new Inter() { public void show() { syso("show"); } } } }

方法重写注意事项: 1.父类中私有方法不能被重写.(父类私有方法子类根本就无法继承) 2.子类重写父类方法时,访问权限不能更低. 最后就一致 3.父类静态方法,子类也必须通过静态方法进行重写. 其实这个算不算方法重写,但是现象确实如此,至于为什么算不上方法重写 子类重写父类方法,最好声明一摸一样.

例题: class Fu { public Person show() { } } class Zi extends Fu { public Student show() { } } class Person { } class Student extends Person { }

运算符:instanceof : 用法: 是双目运算符,左面的操作是一个对象实例,右面是一个类.当左面的对象是右面的类创建的对象时,该运算符 运算的结果是true,否则是false;

说明: 1.一个类的实例包括本身的实例,以及所有直接或间接子类的实例 2.instanceof左边操作元显示的类型与右边操作元必须是同种类或有继承关系 即位于继承树的同一个分支上,否则会编译出错.

冒泡排序:让数组中的元素,从小到大存储.

相邻比较思想. 我们需要比较多少趟 第一趟: 我们要比较几次 len-1; 冒泡排序 : 如果一个数组的长度还是len 那么要比较 len-1趟 下标 0-1 //控制躺数 下标 1-2 for(int i = 0 ; i < len-1; i ++) { 下标 2-3 for(int j = 0 ; j < len-1; j++) { 下标 3-4 比较num3[j]和num3[j+1] 下标 4-5 下标 5-6 } }

第二趟: len-1-1; 0-1 1-2 2-3 3-4 4-5