JAVA 实现容器源码

最新推荐文章于 2022-04-10 13:29:09 发布
最新推荐文章于 2022-04-10 13:29:09 发布
阅读量755 收藏
点赞数
分类专栏： 蜗牛的代码 文章标签： java object integer insert null random

import java.util.*;

public class XYObjArray
{
 int m_nSize;
 int m_nGrowBy;
 int m_nSort;
 Object[] m_pObj;
 public static int nSearchThreshold = 8;
 public static int nSortThreshold = 8;

 static Random randomGen = new Random(new Date().getTime());
 static public final int GetRandomInt(int nMax)
 {
  synchronized(randomGen)
  {
   return randomGen.nextInt(nMax);
  }
 }

 public XYObjArray()
 {
  m_nSize = 0;
  m_nGrowBy = 64;
  m_nSort = 0;
  m_pObj = null;
 }
 public XYObjArray(Object[] pObj, int nGrowBy)
 {
  m_nSize = 0;
  m_nGrowBy = 64;
  m_nSort = 0;
  m_pObj = null;
  SetSize(pObj.length,nGrowBy);
  for(int i=0;i<m_nSize;i++) m_pObj[i] = pObj[i];
 }
 public final synchronized void SetSort(int nSort)
 {
  if(nSort!=m_nSort) Sort(nSort);
 }
 public final synchronized int GetSize()
 {
  return m_nSize;
 }
 public final synchronized void SetSize(int nSize, int nGrowBy)
 {
  if(nSize<0||nGrowBy<=0)
  {
   return;
  }
  if(nSize>m_nSize) m_nSort = 0;
  m_nGrowBy = nGrowBy;
  int nStoreSize = m_pObj==null?0:m_pObj.length;
  if(nSize>=(nStoreSize-m_nGrowBy)&&nSize<=nStoreSize)
  {
   m_nSize = nSize;
   return;
  }
  int nMin = nSize>m_nSize?m_nSize:nSize;
  m_nSize = nSize; 
  Object[] pObj = new Object[(m_nSize/m_nGrowBy+1)*m_nGrowBy];
  if(nMin>0)
  {
   System.arraycopy(m_pObj,0,pObj,0,nMin);
  }
  m_pObj = pObj;
 }
 public final synchronized Object[] GetDataPtr()
 {
  return m_pObj;
 }
 public final synchronized int Add(Object obj)
 {
  int nSort = m_nSort;
  int nIndex = Locate(obj);
  Insert(nIndex, obj);
  m_nSort = nSort;
  return nIndex;
 }
 public final synchronized int Locate(Object obj)
 {
  int nIndex = -1;
  if(m_nSort==0||m_nSize==0) nIndex = m_nSize;
  else
  {
   Comparable ref = (Comparable)obj;
   int nMin, nMax, nMid;
   nMin = 0;
   nMax = m_nSize-1;
   while(nMax-nMin>1)
   {
    nMid = (nMax+nMin)/2;
    if(m_nSort>0)
    {
     if(ref.compareTo(m_pObj[nMid])<0) nMax = nMid;
     else nMin = nMid;
    }
    else
    {
     if(ref.compareTo(m_pObj[nMid])>0) nMax = nMid;
     else nMin = nMid;
    }
   }
   if(m_nSort>0)
   {
    if(ref.compareTo(m_pObj[nMin])<0) nIndex = nMin;
    else if(ref.compareTo(m_pObj[nMax])<0) nIndex = nMax;
    else nIndex = nMax+1;
   }
   else
   {
    if(ref.compareTo(m_pObj[nMin])>0) nIndex = nMin;
    else if(ref.compareTo(m_pObj[nMax])>0) nIndex = nMax;
    else nIndex = nMax+1;
   }
  }
  return nIndex;
 }
 public final synchronized int Find(Object obj)
 {
  if(m_pObj==null) return -1;
  Comparable ref = (Comparable)obj;
  if(m_nSort==0||m_nSize<nSearchThreshold)
  {
   for(int i=0;i<m_nSize;i++)
   {
    if(ref.compareTo(m_pObj[i])==0) return i;
   }
   return -1;
  }
  if(ref.compareTo(m_pObj[0])==0) return 0;
  else if(ref.compareTo(m_pObj[m_nSize-1])==0) return m_nSize-1;
  int nMid, nMin = 0, nMax = m_nSize-1;
  while(nMax-nMin>1)
  {
   nMid = (nMax+nMin)/2;
   if(ref.compareTo(m_pObj[nMid])==0) return nMid;
   if(m_nSort>0)
   {
    if(ref.compareTo(m_pObj[nMid])>0) nMin = nMid;
    else nMax = nMid;
   }
   else
   {
    if(ref.compareTo(m_pObj[nMid])<0) nMin = nMid;
    else nMax = nMid;
   }
  }
  return -1;
 }
 public final synchronized int Insert(int nIndex, Object obj)
 {
  if(nIndex<0||nIndex>m_nSize)
  {
   return -1;
  }
  m_nSort = 0;
  if(nIndex==m_nSize&&m_pObj!=null&&nIndex<m_pObj.length)
  {
   m_pObj[nIndex] = obj;
  }
  else
  {
   int nStoreSize = m_pObj==null?m_nGrowBy:(m_nSize<m_pObj.length?m_pObj.length:(m_nGrowBy+m_pObj.length));
   Object[] pObj = new Object[nStoreSize];
   pObj[nIndex] = obj;
   if(m_pObj!=null)
   {
    if(nIndex>0) System.arraycopy(m_pObj,0,pObj,0,nIndex);
    if(nIndex<m_nSize) System.arraycopy(m_pObj,nIndex,pObj,nIndex+1,m_nSize-nIndex);
   }
   m_pObj = pObj;
  }
  m_nSize++;
  return nIndex;
 }
 public final synchronized int Remove(int nIndex)
 {
  if(nIndex<0||nIndex>=m_nSize)
  {
   return -1;
  }
  int nSegmentSize = m_nSize-nIndex-1;
  if(nSegmentSize>0)
  {
   Object[] pObj = new Object[nSegmentSize];
   System.arraycopy(m_pObj,nIndex+1,pObj,0,nSegmentSize);
   System.arraycopy(pObj,0,m_pObj,nIndex,nSegmentSize);
  }
  m_nSize--;
  return m_nSize;
 }
 public final synchronized Object GetAt(int nIndex)
 {
  if(nIndex<0||nIndex>=m_nSize)
  {
   return null;
  }
  return m_pObj[nIndex];
 }
 public final synchronized int SetAt(int nIndex, Object obj)
 {
  if(nIndex<0||nIndex>=m_nSize)
  {
   return -1;
  }
  m_nSort = 0;
  m_pObj[nIndex] = obj;
  return nIndex;
 }
 public final synchronized void Push(Object obj)
 {
  Insert(m_nSize,obj);
 }
 public final synchronized Object Pop()
 {
  if(m_nSize==0) return null;
  m_nSize--;
  return m_pObj[m_nSize];
 }
 public final synchronized void Sort(int nSort)
 {
  if(m_nSize==0)
  {
   m_nSort = nSort;
   return;
  }
  else if(nSort>0&&m_nSort>0||nSort<0&&m_nSort<0||nSort==0)
  {
   return;
  }
  Object[] pObj = new Object[m_pObj.length];
  int[] pIndex = new int[m_nSize];
  for(int i=0;i<m_nSize;i++) pIndex[i] = i; 
  SortIndex(pIndex, nSort);
  for(int j=0;j<m_nSize;j++) pObj[j] = m_pObj[pIndex[j]];
  m_pObj = pObj;
  m_nSort = nSort;
 }
 public final synchronized void SortIndex(int[] pIndex, int nSort)
 {
  if(m_nSize==0||nSort==0)
  {
   return;
  }
  
  int i,j,k;
  int nMin, nMax;
  int nTemp1, nTemp2, nSwap;
  XYObjArray theStack = new XYObjArray(); 
  int[] pRefIndex = new int[m_nSize];
  for(i=0;i<m_nSize;i++) pRefIndex[i] = i;
  
  theStack.Push(new Integer(0));
  theStack.Push(new Integer(m_nSize-1));

  while(theStack.GetSize()>0)
  {
   nMax = ((Integer)theStack.Pop()).intValue();
   nMin = ((Integer)theStack.Pop()).intValue();
   if(nMax-nMin<nSortThreshold)
   {
    for(i=nMin+1;i<=nMax;i++)
    {
     nTemp1 = pIndex[i];
     nTemp2 = pRefIndex[i]; 
     j = i-1;
     Comparable ref = (Comparable)m_pObj[nTemp1];
     if(nSort>0)
     {
      while(j>=nMin&&(ref.compareTo(m_pObj[pIndex[j]])<0||pRefIndex[j]>nTemp2&&ref.compareTo(m_pObj[pIndex[j]])==0)) j--;
     }
     else
     {
      while(j>=nMin&&(ref.compareTo(m_pObj[pIndex[j]])>0||pRefIndex[j]>nTemp2&&ref.compareTo(m_pObj[pIndex[j]])==0)) j--;
     }
     if(j+1<i)
     {
      for(k=i;k>j+1;k--)
      {
       pIndex[k] = pIndex[k-1];
       pRefIndex[k] = pRefIndex[k-1];
      }
      pIndex[j+1] = nTemp1;
      pRefIndex[j+1] = nTemp2;
     }
    }
   }
   else
   {
    i = nMin+(GetRandomInt(0x7FFFFFFF)%(nMax-nMin))+1;
    nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[i]; pIndex[i] = nSwap;
    nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[i]; pRefIndex[i] = nSwap;
    Comparable ref = (Comparable)m_pObj[pIndex[nMin]];
    if(nSort>0)
    {
     if(ref.compareTo(m_pObj[pIndex[nMin+1]])<0||pRefIndex[nMin+1]>pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[nMin+1]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMin+1]; pIndex[nMin+1] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMin+1]; pRefIndex[nMin+1] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
     if(ref.compareTo(m_pObj[pIndex[nMax]])>0||pRefIndex[nMin]>pRefIndex[nMax]&&ref.compareTo(m_pObj[pIndex[nMax]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMax]; pIndex[nMax] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMax]; pRefIndex[nMax] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
     if(ref.compareTo(m_pObj[pIndex[nMin+1]])<0||pRefIndex[nMin+1]>pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[nMin+1]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMin+1]; pIndex[nMin+1] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMin+1]; pRefIndex[nMin+1] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
    }
    else
    {
     if(ref.compareTo(m_pObj[pIndex[nMin+1]])>0||pRefIndex[nMin+1]>pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[nMin+1]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMin+1]; pIndex[nMin+1] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMin+1]; pRefIndex[nMin+1] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
     if(ref.compareTo(m_pObj[pIndex[nMax]])<0||pRefIndex[nMin]>pRefIndex[nMax]&&ref.compareTo(m_pObj[pIndex[nMax]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMax]; pIndex[nMax] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMax]; pRefIndex[nMax] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
     if(ref.compareTo(m_pObj[pIndex[nMin+1]])>0||pRefIndex[nMin+1]>pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[nMin+1]])==0)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[nMin+1]; pIndex[nMin+1] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[nMin+1]; pRefIndex[nMin+1] = nSwap;
      ref = (Comparable)m_pObj[pIndex[nMin]];
     }
    }
    i = nMin+1;
    j = nMax; 
    while(true)
    {
     if(nSort>0)
     {
      while
      (
       ref.compareTo(m_pObj[pIndex[i]])>0||
       pRefIndex[i]<pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[i]])==0
      ) i++;
      while
      (
       ref.compareTo(m_pObj[pIndex[j]])<0||
       pRefIndex[nMin]<pRefIndex[j]&&ref.compareTo(m_pObj[pIndex[j]])==0
      ) j--;
     }
     else
     {
      while
      (
       ref.compareTo(m_pObj[pIndex[i]])<0||
       pRefIndex[i]<pRefIndex[nMin]&&ref.compareTo(m_pObj[pIndex[i]])==0
      ) i++;
      while
      (
       ref.compareTo(m_pObj[pIndex[j]])>0||
       pRefIndex[nMin]<pRefIndex[j]&&ref.compareTo(m_pObj[pIndex[j]])==0
      ) j--;
     }
     if(i>j)
     {
      nSwap = pIndex[nMin]; pIndex[nMin] = pIndex[j]; pIndex[j] = nSwap;
      nSwap = pRefIndex[nMin]; pRefIndex[nMin] = pRefIndex[j]; pRefIndex[j] = nSwap;
      break;
     }
     nSwap = pIndex[i]; pIndex[i] = pIndex[j]; pIndex[j] = nSwap;
     nSwap = pRefIndex[i]; pRefIndex[i] = pRefIndex[j]; pRefIndex[j] = nSwap;
    }
    if(nMin<j-1)
    {
     theStack.Add(new Integer(nMin));
     theStack.Add(new Integer(j-1));
    }
    if(j+1<nMax)
    {
     theStack.Add(new Integer(j+1));
     theStack.Add(new Integer(nMax));
    }
   }
  }
 }
}

snailbreak
关注
专栏目录
Java 容器类源码详解 Set
08-25
Java 容器类源码详解 Set Java 容器类源码详解 Set 是 Java 集合框架中的一种重要的集合类型，直接扩展自 Collection 接口。Set 表示由无重复对象组成的集合，在一个 Set 中，不能有两个引用指向同一个对象，或两个...
java容器
qq_47897078的博客
07-14 2770
Collection集合List 有序集合，允许重复的元素ArrayList：底层用Object数组实现，特点是查询效率高，增删效率低，线程不安全LinkedList：底层使用双向循环链表实现，特点是查询效率低，增删效率高，线程不安全，因为线程不同步Vector：底层用长度可以动态增长的对象数组实现，它的相关方法用 Synchronized 进行了线程同步，所以线程安全，效率低Stack：栈。特点是：先进后出。继承于VectorSet 无序集合，不允许重复的元素HashSet：底层用HashMap实现，本质
java如何实现容器,Java | 实现一个简单的 IOC 容器 (一)
weixin_39575212的博客
03-15 171
实现一个简单的 IOC 容器 (一)这篇文章主要讲一下如何使用 Java 实现一个简单的 IOC 容器，这里该系列的第一篇，要实现的内容的也相对简单，主要介绍一下 B 依赖 A 这种简单的关系是怎么实现的ioc_node.pngJava 依赖注入标准 JSR-330 实现我们常常使用的 Java DI 框架包括 Spring 和 Guice，在 Java 规范中也定义了对依赖注入的基本规范，其就是...
基于java的容器底层原理实现
萌萌的PP博客
11-13 8412
一.java容器的体系大览 1. java为啥子需要容器呢? 通常，程序总是在运行时才能确定要创建的对象，甚至是对象的类型。为了解决这个问题，需要在任意时刻任意位置创建任意数量的对象。大多数语言都提供某种方法来解决这个问题，Java使用容器来解决这个问题。容器也称集合类，基本的类型是List、Set、Queue、Map，但由于Java类库中使用了Collection关键字来代表某一接口，所以一般...
Java容器源码解析
void
07-25 1615
Java容器源码解析，迭代器详解，Map、List、Set源码解析
Java容器类源码详解 Deque与ArrayDeque
08-25
Java 容器类源码详解 Deque 与 ArrayDeque Java 容器类源码详解 Deque 与 ArrayDeque 主要介绍了 Java 容器类源码详解 Deque 与 ArrayDeque，Deque 接口继承自 Queue 接口，但 Deque 支持同时从两端添加或移除元素...
java并发容器CopyOnWriteArrayList实现原理及源码分析
08-30
Java并发容器CopyOnWriteArrayList实现原理及源码分析 Java并发容器CopyOnWriteArrayList是Java并发包中提供的一个并发容器，实现了线程安全且读操作无锁的ArrayList，写操作则通过创建底层数组的新副本来实现。...
java源码包---java 源码 大量 实例
04-18
　Java实现HTTP连接与浏览，Java源码下载，输入html文件地址或网址，显示页面和HTML源文件，一步步的实现过程请下载本实例的Java源码，代码中包括丰富的注释，对学习有帮助。 Java实现的FTP连接与数据浏览程序 1个...
一个Java外卖系统源码.zip
05-29
- **部署**：Docker和Kubernetes可实现容器化部署和集群管理。 综上所述，Java外卖系统是一个涵盖多领域技术的复杂项目，从数据库设计、前后端交互到业务逻辑处理，都需要开发者具备扎实的技术基础和良好的系统...
Java容器类源码-ArrayList的最全的源码分析
热门推荐
RyanLee的专栏
07-27 5万+
本文是针对Java 1.8的源代码进行解析的，可能会和其他版本有所出入。 笔者技术真的是一般般，写这个为了加深理解的同时给害怕看源代码的朋友一点鼓励，所以笔者在写的过程中有查阅很多资料来努力减少错误，但是如有错漏之处，希望大神们指出，我会第一时间修改，以免误人子弟，也希望和笔者一样基础不够好的朋友不要畏惧看源码，源码看起来并不会很难，而且多看源代码会对Java更深刻的理解。
java如何实现容器_Java的容器都有哪些，怎么实现的
weixin_28689969的博客
02-24 145
String,java.util下的集合容器==============================================================================数组长度限制为 Integer.Integer.MAX_VALUE;String的长度限制: 底层是char 数组 长度 Integer.MAX_VALUE 线程安全的java.util下的集合容器这...
java容器超详细
pony的博客
04-28 9526
前言 java容器是前人为我们提供的一套用于存储数据和对象的工具。如果你学过C++的STL，可以与之类比。java容器又可以称为Java Collection Framework（JCF）。里面除了存储对象的容器之外，还提供了一套用于处理和操作容器里面的对象的一套工具类。 整体框架： 下面将介绍List、Set、Map以及工具类Collections和Arrays。 List List：列表，...
Java 容器---实现
qq_34579060的博客
01-19 794
“工欲善其事，必先利其器”。Java 容器就是我们开发中的利器。 然而，之前在开发中使用仅仅是容器的一小部分。这次从源码的角度进行深入的理解，一点总结分享给大家。 这里只列举了非阻塞式的容器；阻塞式的容器，会在后面的并发篇补。 如果有什么理解不对的地方，欢迎大家在评论中指正～ ArrayList 实现： 数组实现 线程安全： 非线性安全，fail-fast 机制保护 容量： 初始容量为10；随后
Java容器核心源码详细分析
qq_52400091的博客
03-25 179
01-ArrayList 源码详细分析 文章目录01-ArrayList 源码详细分析前言一、首先我们得了解什么是容器二、容器的结构1.第一步我们先看到ArrayList类的结构2.添加元素过程总结 前言 很多小伙伴们也许和我一样，在初学容器这一章节是只是简简单单的学习了API的使用，例如 添加元素到ArrayList容器里面，移除元素，却不知道或不理解底层原理是如何实现，今天在第二遍学习之后，在这留下学习的痕迹，希望帮助到更多的铁子们！ 一、首先我们得了解什么是容器 所谓容器，是用来容纳物体、管理物体。
java容器源码_java容器源码分析(一)——开篇
weixin_39598568的博客
02-19 144
近来打算跳槽，打算把java基础方面的知识好好复习一下，一方面是为面试做准备。另一方面当做工作一年来的知识总结吧。先来复习下java容器方面的。容器的两大基类在整个集合框架的体系中，有两大类：CollectionMap其中Collection的子类是线性集合，Map是key-value集合，简单的分类如下(来自java编程思想) 总的来说，我们的容器只有四种，然后每种容器有若干不同的实现，如Lis...
Java容器(二)——Map体系详解及源码分析
叫兽yeliheng的博客
04-10 764
Map 上一篇我们详细了解了Java容器中的Collection体系，今天我们来对Java容器的另一个重要接口Map进行详细分析。 Map 接口存在于java.util包中，它用于表示键和值之间的映射，Map的键是唯一的。 Map十分适用于需要键值对映射的场景。 Map的特点 Map中不能包含重复的键，每个键最多可以映射到一个值。 Map接口下的一些子接口允许空键和空值。（下文介绍） Map中元素的顺序取决于具体接口的实现。例如：TreeMap和LinkedHashMap中的元素具有先进先出的规则，而Ha
java的容器框架结构_Java 8 容器源码-整体结构
weixin_39692761的博客
02-16 125
为什么需要Java容器通常，程序总是在运行时才能确定要创建的对象的数量，甚至是对象的类型。为了解决这个问题，需要在任意时刻任意位置创建任意数量的对象。大多数语言都提供某种方法来解决这个问题，Java使用容器来解决这个问题。容器也称集合类，基本的类型是List、Set、Queue、Map，但由于Java类库中使用了Collection关键字来代表某一接口，所以一般用容器来称呼这些集合类。Java容器...
Java 容器从入门到精通
Umbrella Corporation
10-12 1万+
一、概览 Collection Map 二、容器中的设计模式 迭代器模式 适配器模式 三、源码分析 ArrayList Vector CopyOnWriteArrayList LinkedList HashMap ConcurrentHashMap LinkedHashMap WeakHashMap 附录 参考资料 一、概览 容器主要包括 Collection 和 Map...
Java五子棋游戏源码实现详解
"这是一个基于Java实现的五子棋游戏程序，包含源代码，可以在手机或计算机上运行。程序使用了AWT库来构建图形用户界面，实现了基本的游戏逻辑和交互功能，如玩家选择先手、落子操作以及游戏重置等。" 在Java编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值