本文详细介绍了Java编程中的数组操作，包括增删元素的优化方法，以及冒泡排序、插入排序、选择排序和快速排序等经典排序算法的实现。此外，还探讨了Java集合框架，如ArrayList的内部实现原理和操作，以及HashMap的数据结构和基本操作。文章深入浅出地展示了面向对象的封装、继承和多态特性，并提供了相关案例。通过对这些基础知识的讲解，有助于提升Java编程能力。
1、数组操作
（1）增
int[] array = {2,5,13,27,55,57,76,82,99};//建有序数组
Scanner input = new Scanner(System.in);
System.out.println("请输入需要插入的值：");
int t = input.nextInt();//读取控制台输入的值
int i = array.length-2;//数组插入末尾默认补个0，所以array.length-2就是99的位置
for (; i >=0 ; i--) {
if (array[i]>t){
array[i+1] = array[i];
}else{
break;
}
}
array[i+1] = t;
for (int i1 : array) {
System.out.println(i1);
}
（2）删
优化前：
int[] array = {2,5,13,27,55,57,76,82,99};
Scanner input = new Scanner(System.in);
System.out.println("请输入需要删除的元素的值：");
int t = input.nextInt();
int i = 0;
for (; i < array.length ; i++) {//先找
if (array[i]==t){
break;
}
}
if (i==array.length){
System.out.println(t+"不存在");
}else{
for (int j = i; j < array.length-1; j++) {
array[j] = array[j+1];
}
array[array.length-1] = 0;//切记
System.out.println("删除"+t+"成功");
for (int i1 : array) {
System.out.println(i1);
}
}
优化后：
boolean start = false;//假设找不到
for (int i = 0; i < array.length-1; i++) {
if (start){//找到
array[i] = array[i+1];
}else{//没找到
if (array[i]==t){//先执行else操作，找到就改为true
start = true;
}
}
}
if (start){
array[array.length-1] = 0;
for (int i : array) {
System.out.println(i);
}
}else{
System.out.println("不存在"+t);
}
2、排序法
生成随机数组：
Random rand = new Random();
int[] array = new int[10];
int size = 0;
array[size++] = 1+rand.nextInt(100);
boolean no;
for (int i; size < array.length;) {
i = 1+rand.nextInt(100);
no = true;
for (int j = 0; j < size; j++) {//判断10个随机数各不相同
if (array[j]==i){
no = false;
break;
}
}
if (no){//生成了不同的随机数则添加
array[size++] = i;
}
}
冒泡法：
for (int i = 0,item; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if (array[j]>array[j+1]){//两两比较，每当满足条件就需要交换一次
item = array[j];
array[j] = array[j+1];
array[j+1] = item;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.println("排序后："+array[i]);
}
插入排序法：
for (int i = 1,t,j=0; i < array.length; i++) {
if (array[i]>=array[i-1]){
continue;
}
t = array[i];
for (j = i-1; j >=0 && t<array[j]; j--) {
array[j+1] = array[j];
}
array[j+1] = t;
}
for (int i : array) {
System.out.println("排序后："+i);
}
选择排序：
for (int i = 0; i < array.length-1; i++) {
int maxValueIx = 0;
int maxIx = array.length-1-i;
for (int j = 1; j <= maxIx; j++) {
if (array[maxValueIx]<array[j]){
maxValueIx = j;
}
}
if (maxValueIx != maxIx){//每一轮循环只需要交换一次
int t = array[maxIx];
array[maxIx] = array[maxValueIx];
array[maxValueIx] = t;
}
}
for (int i : array) {
System.out.println(i);
}
快速排序：
public static void quick_sort(int s[],int l, int r)
{
if (l < r)
{
//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
int i = l, j = r, x = s[l];
while (i < j)
{
while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
j--;
if(i < j)
s[i++] = s[j];
while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
i++;
if(i < j)
s[j--] = s[i];
}
s[i] = x;
quick_sort(s, l, i - 1); // 递归调用
quick_sort(s, i + 1, r);
}
}
3. 面对对象特征（封装、继承（组合）、多态+案例演示）
（1）封装
广义封装
模块封装
remote封装（EJB）
EJB概述：EJB是sun的服务器端组件模型，
用EJB技术部署的分布式系统可以不限于特定的平台
其特点包括网络服务支持和核心开发工具(SDK)
狭义封装
权限封装 public protected default private
包封装（3-6层）
3层：到包名
4层：到业务模型
5层：包名+依赖工具+业务接口
6层：包名+依赖工具+中间键+业务接口
get\set数据封装
接口封装：暴露功能，屏蔽实现
（2）继承
单根继承，多实现
无法继承：
构造器和私有方法
不同包父类受protected类型无法继承
特殊词汇作用：
final：加在属性上：属性值不可变
加在方法上：不可在子类中重写
加在类上：不能被继承，和abstract相反
加在包上：空包
finally：同常放在try。。。catch后，多用于资源的释放
finally中的代码只要jvm不关闭则都可执行
finalize：Object中定义的方法，finalize方法用于在垃圾收集器将
对象从内存中清除出去之前做清理工作，在垃圾收集器
销毁对象时调用，通过重写可以整理系统资源或者执行
其他清理工作
this： 指代不同：指当前对象的引用，应该为构造函数中的第一条语句，可以出现在非静态方法或代码块中
调用函数不同：可以实现当前类中的一个构造方法中调用其他同参的构造方法
引用对象不同：this.当前对象名
super： 指代不同：指当前对象bai里面du的父对象的引zhi用
调用函数不同：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
引用对象不同：引用当前对象的直接父类中的成员
static：加在属性上：由类创建的所有的对象，都共用这一属性
类变量的加载早于对象
类变量存放在静态域中
加在方法上：JVM启动时装载字节码文件过程中创建所有静态内容，仅一份
类方法内部可以调用静态的属性和静态的方法，而不能调用非静态的属性和方法
但是，非静态方法可以调用静态的属性和方法
加在类上： 普通类是不可以被静态修饰的，只有内部类可以
无需对象，通过类名就可以访问
（3）多态
形式：
重写：同一个类中名称相同参数不同（参数类型不同，个数不同，顺序不同）的方法
重载：子类重写与父类同名，同参，同返回值的方法
解释：
上转型（转父）小转大：
自动类型装换：父类引用指向子类对象Student stu = new KBStudent();
下转型（转子）大转小：
强制类型转换：通过instanceof运算符判定父类引用指向子类对象的实际类型
4、集合
Collection的方法：
add(Object o)：增加元素
addAll(Collection c)：...
clear()：...
contains(Object o)：是否包含指定元素
containsAll(Collection c)：是否包含集合c中的所有元素
iterator()：返回Iterator对象，用于遍历集合中的元素
remove(Object o)：移除元素
removeAll(Collection c)：相当于减集合c
retainAll(Collection c)：相当于求与c的交集
size()：返回元素个数
toArray()：把集合转换为一个数组
TreeSet的方法：
first()：返回第一个元素
last()：返回最后一个元素
lower(Object o)：返回指定元素之前的元素
higher(Obect o)：返回指定元素之后的元素
subSet(fromElement, toElement)：返回子集合
List的方法：
add(int index, Object o)：在指定位置插入元素
addAll(int index, Collection c)：...
get(int index)：取得指定位置元素
indexOf(Obejct o)：返回对象o在集合中第一次出现的位置
lastIndexOf(Object o)：...
remove(int index)：删除并返回指定位置的元素
set(int index, Object o)：替换指定位置元素
subList(int fromIndex, int endIndex)：返回子集合
Queue的方法：
boolean add(E e) : 将元素加入到队尾，不建议使用
boolean offer(E e): 将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。推荐使用此方法取代add
E remove(): 获取头部元素并且删除元素，不建议使用
E poll(): 获取头部元素并且删除元素，队列为空返回null；推荐使用此方法取代remove
E element(): 获取但是不移除此队列的头
E peek(): 获取队列头部元素却不删除元素，队列为空返回null
ArrayDeque和Deque的方法：
addFirst(Object o)：元素增加至队列开头
addLast(Object o)：元素增加至队列末尾
poolFirst()：获取并删除队列第一个元素，队列为空返回null
poolLast()：获取并删除队列最后一个元素，队列为空返回null
pop()：“栈”方法，出栈，相当于removeFirst()
push(Object o)：“栈”方法，入栈，相当于addFirst()
removeFirst()：获取并删除队列第一个元素
removeLast()：获取并删除队列最后一个元素
（3）ArrayList
添加：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
public void add(int index,E element){
rangeCheckForAdd(index);
ensureCapacityInternal(size+1);
System.arraycopy(elementData,index,elementData,index+1,size-index);
elementData[index] = element;
size++;
}
public boolean addAll(Collection<? extends E>c){
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size+numNew);
System.arraycopy(a,0,elementData,size,numNew);
size += numNew;
return numNew !=0;
}
public boolean addAll(int index,Collection<? extends E>c){
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size+numNew);
int numMoved = size-index;
if(numMoved > 0){
System.arraycopy(elementData,index,elementData,index+1,numMoved)
System.arraycopy(a,0,elementData,index,numNew);
size += numNew;
return numNew != 0;
}
}
删除：
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
（3）HashMap代码
package kb08.util.map;
import com.sun.org.apache.xpath.internal.operations.Bool;
import kb08.util.Iterator;
import kb08.util.List;
import kb08.util.Map;
import kb08.util.array.ArrayList;
import kb08.util.link.LinkedList;
public class HashMap<K,V> implements Map<K,V> {
private static final int DEFAULT_CAPACITY = 16;//默认容量
private static final float EXPAND_FACTOR = 0.75f;//扩容因子
private static final float REDUCE_FACTOR = 0.25F;//收缩因子
private static final Object[] EMPTY = {};
private float expandFactor;
private Object[] elementDate;//数据数组
private int size;
public HashMap(){
this(DEFAULT_CAPACITY,EXPAND_FACTOR);
}
public HashMap(int capacity,float expandFactor){//用户自定义扩容因子和容量要满足一下范围，只是进行初始化
initElementData(capacity);
this.expandFactor = expandFactor<=0.5 || expandFactor>=0.75 ? EXPAND_FACTOR : expandFactor;
//输入一个扩容因子和EXPAND_FACTOR进行比较
}
private void initElementData(int capacity){
elementDate = capacity<=1 ? EMPTY : new Object[Integer.highestOneBit(capacity-1)<<1];
}
/**
* 判定什么时候需要扩容
* @return -1:缩 0：不变 1：扩
*/
private int needChange(){
double factor = size*1.0/elementDate.length;
return factor>=expandFactor ? 1 : factor<=REDUCE_FACTOR ? -1 : 0;
}
private void expand(){
change(true);
}
private void reduce(){
change(false);
}
//扩容：散列均匀，减少链表的数量和长度
private void change(boolean expand){
Object[] copy = elementDate;//备份
size = 0;
initElementData(expand ? elementDate.length<<1 : elementDate.length>>1);
for (Object o : copy) {
if (null==o){
continue;
}
if (o instanceof Entry){
put((Entry<K, V>) o);
continue;
}
Iterator<Entry<K, V>> it = ((LinkedList<Entry<K, V>>) o).iterator();
while (it.hasNext()){
put(it.next());
}
}
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return 0==size;
}
@Override
public boolean containsKey(K key) {
return null != _get(key);
}
@Override
public boolean containsValue(V value) {
Iterator<V> it = values().iterator();
while (it.hasNext()){
V v = it.next();
if (value == v || (null!=value && value.equals(v)) || (null!=v && v.equals(value))){
return true;
}
}
return false;
}
private Entry<K,V> _get(K key){
int index = index(key);
Object o = elementDate[index];
Entry<K,V> e = null;
if (null!=o){
if (o instanceof Entry){
e = (Entry<K,V>)o;
}else{
Iterator<Entry<K,V>> it = ((LinkedList<Entry<K,V>>)o).iterator();
while (it.hasNext()) {
if (key.equals(it.next().getKey())){
e = it.next();
break;
}
}
}
}
return e;
}
@Override
public V get(K key) {
Entry<K,V> e = _get(key);
return null == e ? null : e.getValue();
}
private int index(K key){
return null==key ? elementDate.length-1 :
key.hashCode()%(elementDate.length-1);
}
private V put(Entry<K,V> entry){
if (1==needChange()){
expand();
}
int index = index(entry.getKey());
Object o = elementDate[index];
V v = null;
boolean noRepeat = true;
if (null==o){
elementDate[index] = entry;
}else if (o instanceof Entry){
Entry<K,V> e = (Entry<K,V>) o;//e是旧值
if (null==e.getKey() || e.getKey().equals(entry.getKey())){
v = e.getValue();
e.setValue(entry.getValue());
noRepeat = false;
}else {
LinkedList<Entry<K,V>> list = new LinkedList<>();
list.add(e);
list.add(entry);
elementDate[index] = list;
}
}else {
LinkedList<Entry<K, V>> list = (LinkedList<Entry<K, V>>) o;
Iterator<Entry<K,V>> it = list.iterator();
while (it.hasNext()){
Entry<K,V> e = it.next();
if (e.getKey().equals(entry.getKey())){
v = e.getValue();
e.setValue(entry.getValue());
noRepeat = false;
break;
}
}
if (noRepeat){
list.add(entry);
}
}
if (noRepeat){
size++;
}
return v;
}
@Override
public V put(K key, V value) {
return put(new Entry<>(key,value));
}
@Override
public V remove(K key) {
if (needChange()==-1){
reduce();
}
int index = index(key);
Object o = elementDate[index];
V v = null;
boolean exist = false;
if (null != o){
if (o instanceof Entry){
v = ((Entry<K,V>)o).getValue();
elementDate[index] = null;//数组删除：提出元素后返回null
exist = true;
}else{
LinkedList<Entry<K, V>> list = (LinkedList<Entry<K, V>>) o;
Iterator<Entry<K, V>> it = list.iterator();
while (it.hasNext()){
Entry<K, V> e = it.next();
if (e.getKey().equals(key)){
it.remove();//链表删除：remove
v = e.getValue();
exist = true;
break;
}
}
if (exist && list.size()==1){
elementDate[index] = list.get(0);
}
}
}
if (exist){
size--;
}
return v;
}
@Override
public List<K> keys() {
List<K> list = new ArrayList<>(size);//把获取的键值放在数组中
for (Object o : elementDate) {
if (null==o){
continue;
}
if (o instanceof Entry){
list.add(((Entry<K,V>)o).getKey());
}else {
Iterator<Entry<K,V>> it = ((LinkedList<Entry<K,V>>)o).iterator();
while (it.hasNext()){
list.add(it.next().getKey());
}
}
}
return list;
}
@Override
public List<V> values() {
List<V> list = new ArrayList<>(size);
Iterator<K> it = keys().iterator();
while (it.hasNext()){
list.add(get(it.next()));
}
return list;
}
@Override
public List<Entry<K, V>> entries() {
List<Entry<K, V>> list = new ArrayList<>(size);
Iterator<K> it = keys().iterator();
while (it.hasNext()){
list.add(_get(it.next()));
}
return list;
}
}
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
