读取词典
@param storage 储存空间
@param reverse 是否翻转键值对
@param pathArray 路径
@return 是否加载成功
338240
static boolean load(Map<String, String> storage, boolean reverse, String... pathArray)
    {
        StringDictionary dictionary = new StringDictionary("=");
        for (String path : pathArray)
        {
            if (!dictionary.load(path)) return false;
        }
        if (reverse) dictionary = dictionary.reverse();
        Set<Map.Entry<String, String>> entrySet = dictionary.entrySet();
        for (Map.Entry<String, String> entry : entrySet)
        {
            storage.put(entry.getKey(), entry.getValue());
        }

        return true;
    }
578651
public static MutableFst reverse(Fst infst) {
    infst.throwIfInvalid();

    MutableFst fst = ExtendFinal.apply(infst);

    Semiring semiring = fst.getSemiring();

    MutableFst result = new MutableFst(fst.getStateCount(), semiring);
    result.setInputSymbolsAsCopy(fst.getInputSymbols());
    result.setOutputSymbolsAsCopy(fst.getOutputSymbols());
    MutableState[] stateMap = initStateMap(fst, semiring, result);

    for (int i = 0; i < fst.getStateCount(); i++) {
      State oldState = fst.getState(i);
      MutableState newState = stateMap[oldState.getId()];
      for (int j = 0; j < oldState.getArcCount(); j++) {
        Arc oldArc = oldState.getArc(j);
        MutableState newNextState = stateMap[oldArc.getNextState().getId()];
        double newWeight = semiring.reverse(oldArc.getWeight());
        result.addArc(newNextState, oldArc.getIlabel(), oldArc.getOlabel(), newState, newWeight);
      }
    }
    return result;
  }
1192154
static boolean load(String path, AhoCorasickDoubleArrayTrie<String> trie, boolean reverse)
    {
        String datPath = path;
        if (reverse)
        {
            datPath += Predefine.REVERSE_EXT;
        }
        if (loadDat(datPath, trie)) return true;
        // 从文本中载入并且尝试生成dat
        TreeMap<String, String> map = new TreeMap<String, String>();
        if (!load(map, reverse, path)) return false;
        logger.info("正在构建AhoCorasickDoubleArrayTrie，来源：" + path);
        trie.build(map);
        logger.info("正在缓存双数组" + datPath);
        saveDat(datPath, trie, map.entrySet());
        return true;
    }
356111
public static Stack<String> reversePath(List<String> pathParts) {
        Stack<String> pathStack = new Stack<String>();
        if (pathParts != null) {
            // Needs first extra argument at top of the stack
            for (int i = pathParts.size() - 1;i >=0;i--) {
                pathStack.push(pathParts.get(i));
            }
        }
        return pathStack;
    }
683165
function seekArray(data, pathArr, result, key) {
    var subpath = pathArr[1];
    var path = pathArr[0];
    var seek = jsonPath.eval(data, path) || [];

    if (seek.length && subpath) {
      result = result[key] = [];

      seek[0].forEach(function(item, index) {
        walk(item, subpath, result, index);
      });
    } else {
      result[key] = seek;
    }
  }
35332
public void reverse() {
		for (int i = 0; i < size / 2; i++) {
			T tmp = data[i];
			data[i] = data[size - i - 1];
			data[size - i - 1] = tmp;
		}
	}
397278
private static void reverse(final byte[] arr, final int len) {
        for (int l = 0, r = 0 + len - 1; l < r; l++, r--) {
            final byte tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
        }
    }
1192525
private void writePrimitiveArrayFallback(Object array) {
        writeAMF3();
        buf.put(AMF3.TYPE_ARRAY);
        
        if (hasReference(array)) {
            putInteger(getReferenceId(array) << 1);
            return;
        }
        storeReference(array);
        
        amf3_mode += 1;
        int count = Array.getLength(array);
        putInteger(count << 1 | 1);
        putString("");
        for (int i = 0; i < count; i++) {
            Serializer.serialize(this, Array.get(array, i));
        }
        amf3_mode -= 1;
    }
758596
def reversed(self):
        """"""
        newpath = [seg.reversed() for seg in self]
        newpath.reverse()
        return Path(*newpath)
1072818
private function array_reverse_iterator (array $a, $preserveKeys = false)
  {
    if ($preserveKeys)
      for (end ($a); ($key = key ($a)) !== null; prev ($a))
        yield $key => current ($a);
    else for (end ($a); ($key = key ($a)) !== null; prev ($a))
      yield current ($a);
  }
184234
public static void reverse(final Object[] arr, final int pos, final int len) {
        for (int l = pos, r = pos + len - 1; l < r; l++, r--) {
            final Object tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
        }
    }
1319419
public static <T> List<T> getReversed(Collection<T> collection) {
        List<T> reversedList = new ArrayList<>(collection);
        Collections.reverse(reversedList);
        return reversedList;
    }
640693
def reverse_fd(inf, outf):
    '''
    '''
    inf.seek(0, 2)
    size = inf.tell()
    if not size:
        return

    chunks = split_size(size)
    for chunk in reversed(chunks):
        inf.seek(chunk[0], 0)
        data = inf.read(chunk[1])
        if len(data) != chunk[1]:
            raise IOError('incomplete I/O operation')
        outf.write(data[::-1])
1143426
private void reverse(byte[] buffer, int offset, int length) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "reverse", new Object[] { buffer, offset, length });

        byte temp;
        for (int i = 0; i < length / 2; i++) {
            temp = buffer[offset + i];
            buffer[offset + i] = buffer[offset + (length - 1) - i];
            buffer[offset + (length - 1) - i] = temp;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "reverse");
    }
966062
public static byte[] reverse(byte[] data) {
        for (int i = 0, j = data.length - 1; i < data.length / 2; i++, j--) {
            data[i] ^= data[j];
            data[j] ^= data[i];
            data[i] ^= data[j];
        }
        return data;
    }
34170
public JimfsPath toRealPath(
      JimfsPath path, PathService pathService, Set<? super LinkOption> options) throws IOException {
    checkNotNull(path);
    checkNotNull(options);

    store.readLock().lock();
    try {
      DirectoryEntry entry = lookUp(path, options).requireExists(path);

      List<Name> names = new ArrayList<>();
      names.add(entry.name());
      while (!entry.file().isRootDirectory()) {
        entry = entry.directory().entryInParent();
        names.add(entry.name());
      }

      // names are ordered last to first in the list, so get the reverse view
      List<Name> reversed = Lists.reverse(names);
      Name root = reversed.remove(0);
      return pathService.createPath(root, reversed);
    } finally {
      store.readLock().unlock();
    }
  }
1014984
public static <T> T[] reverseArray(T[] arr) {
		for (int left = 0, right = arr.length - 1; left < right; left++, right--) {
			T temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
		}
		return arr;
	}