常见的几种数据结构:
* 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