DataBuffer

ממשק ציבורי DataBuffer
תת-מחלקות עקיפות ידועות

מיכל של נתונים מסוג מסוים.

מופעים של DataBuffer ממפים מקטעי זיכרון מקוריים או ערמה לתצוגה ליניארית התומכת ב:

  • אינדקס של 64 סיביות, המאפשר לעבוד עם חיץ גדול מ-2 31 בתים
  • אחסון חפצים מכל סוג ולא רק פרימיטיביים
  • טיפוסים גנריים מאפשרים לעבוד ישירות גם עם סוגי מאגר, דבר שאינו דורש סוגי מאגר מפורשים כמו עם מאגרי ה-JDK הסטנדרטיים.
חשוב לציין שאין ערובה לכך שהזיכרון המנוהל על ידי DataBuffer הוא ליניארי, במיוחד כאשר עוסקים בטיפוסים לא פרימיטיביים או במאגרים גדולים.

שיטות ציבוריות

תקציר <R> R
קבל (מבקר DataStorageVisitor <R>)
מבקר באחסון הגיבוי של מאגר זה.
מופשט DataBuffer <T>
copyTo ( DataBuffer <T> dst, גודל ארוך)
כתוב את ההפניות של האובייקטים במערך המקור לתוך המאגר הזה.
בוליאני מופשט
שווה (Object obj)
בודק שוויון בין מאגרי נתונים.
תקציר T
getObject (אינדקס ארוך)
קורא את הערך באינדקס הנתון.
בוליאני מופשט
הוא קריאה בלבד ()
מודיע אם מאגר זה מגובה במערך נגיש או לא.
מופשט DataBuffer <T>
צר (גודל ארוך)
יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של התוכן של מאגר זה, שגודלו מוגדר לערך הנתון.
מופשט DataBuffer <T>
היסט (מדד ארוך)
יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של תוכן מאגר זה, החל מהאינדקס הנתון.
מופשט DataBuffer <T>
קרא (T[] dst)
קרא את ההפניות של האובייקטים במאגר זה למערך היעד.
מופשט DataBuffer <T>
read (T[] dst, int offset, int length)
קרא את ההפניות של האובייקטים במאגר זה למערך היעד.
מופשט DataBuffer <T>
setObject (ערך T, אינדקס ארוך)
כותב את הערך הנתון למאגר הזה באינדקס הנתון.
מופשט ארוך
גודל ()
גודל המאגר, באלמנטים.
מופשט DataBuffer <T>
פרוסה (מדד ארוך, גודל ארוך)
יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של תוכן מאגר זה, החל מהאינדקס הנתון ובגודל הנתון.
תקציר DataBufferWindow <? מרחיב את DataBuffer <T>>
חלון (בגודל ארוך)
יוצר DataBufferWindow המספק תצוגה חלקית של מאגר זה.
מופשט DataBuffer <T>
כתוב (T[] src)
כתוב את ההפניות של האובייקטים במערך המקור לתוך המאגר הזה.
מופשט DataBuffer <T>
כתוב (T[] src, int offset, int length)
שיטת הצבת בכמות גדולה, באמצעות מערכי int.

שיטות ציבוריות

public abstract R accept ( מבקר DataStorageVisitor <R>)

מבקר באחסון הגיבוי של מאגר זה.

יישום המאגר אחראי להעביר חזרה הפניה לאחסון הנתונים בפועל למבקר שסופק. המבקר אינו צריך לטפל בכל סוגי אחסון הנתונים האפשריים והוא יכול לעקוף רק את שיטות האחסון בהן הוא מעוניין בפועל. עבור כל סוג אחר של אחסון, קריאה זו תחזור ל- fallback() כך שהמבקר יוכל לבצע שגרה כללית כלשהי אם נָחוּץ.

פרמטרים
אוֹרֵחַ מבקר באחסון הנתונים של מאגר זה
מחזיר
  • אותו ערך שהוחזר על ידי המבקר

תקציר ציבורי DataBuffer <T> copyTo ( DataBuffer <T> dst, גודל ארוך)

כתוב את ההפניות של האובייקטים במערך המקור לתוך המאגר הזה.

אם יש יותר ערכים להעתקה מגודל מאגר היעד, כלומר size > dst.size() , אז לא מועברים ערכים ונזרק BufferOverflowException. מצד שני, אם יש יותר ערכים להעתיק מגודל מאגר המקור, כלומר > src.size() , אז נזרק BufferUnderfloatException.

אחרת, שיטה זו מעתיקה ערכי n = size ממאגר זה למאגר היעד.

פרמטרים
dst מאגר היעד שאליו מועתקים ערכים; אסור להיות החיץ הזה
גוֹדֶל מספר הערכים להעתקה למאגר היעד
מחזיר
  • החיץ הזה
זורק
חריג טיעון לא חוקי אם מאגר היעד הוא מאגר זה
ReadOnlyBufferException אם מאגר היעד הוא לקריאה בלבד
BufferOverflowException אם אין מספיק מקום במאגר היעד
BufferUnderflowException אם אין מספיק ערכים במאגר המקור

תקציר בוליאני ציבורי שווה (Object obj)

בודק שוויון בין מאגרי נתונים.

מאגר נתונים שווה לאובייקט אחר אם אובייקט זה הוא DataBuffer אחר באותו גודל, סוג והאלמנטים שווים ובאותו סדר. לְדוּגמָה: 

IntDataBuffer buffer = DataBuffers.of(1, 2, 3);

 assertEquals(buffer, DataBuffers.of(1, 2, 3));  // true
 assertEquals(buffer, DataBuffers.ofObjects(1, 2, 3));  // true, as Integers are equal to ints
 assertNotEquals(buffer, DataBuffers.of(1, 2, 3, 0));  // false, different sizes
 assertNotEquals(buffer, DataBuffers.of(1, 3, 2));  // false, different order
 assertNotEquals(buffer, DataBuffers.of(1L, 2L, 3L));  // false, different types

שים לב שהחישוב הנדרש לאימות שוויון בין שני מאגרים יכול להיות יקר במקרים מסוימים ולכן, מומלץ לא להשתמש בשיטה זו בנתיב קריטי שבו יש חשיבות לביצועים.

פרמטרים
obj אובייקט להשוות איתו את המאגר הזה
מחזיר
  • true אם המאגר הזה שווה לאובייקט שסופק

תקציר ציבורי T getObject (אינדקס ארוך)

קורא את הערך באינדקס הנתון. חשוב: השימוש בשיטה זו צריך להיות מוגבל למאגרים מסוגים לא פרימיטיביים או כאשר סוג הנתונים אינו ידוע באופן דטרמיניסטי על ידי המתקשר. בכל מקרה אחר, העדיפו את השימוש בגרסה הפרימיטיבית שלו שתשפר משמעותית את הביצועים (למשל IntDataBuffer.getInt(idx)

פרמטרים
מַדָד המדד שממנו ייקרא הצוף
מחזיר
  • הערך במדד הנתון
זורק
IndexOutOfBoundsException אם האינדקס שלילי או לא קטן מגודל המאגר

תקציר ציבורי בוליאני הוא קריאה בלבד ()

מודיע אם מאגר זה מגובה במערך נגיש או לא.

מחזיר
  • נכון אם ורק אם מאגר זה הוא לקריאה בלבד

Public abstract DataBuffer <T> צר (גודל ארוך)

יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של התוכן של מאגר זה, שגודלו מוגדר לערך הנתון.

הגודל החדש לא יכול להיות גדול מגודל המאגר הזה. שינויים בתוכן המאגר הזה יהיו גלויים במאגר החדש ולהיפך. המאגר החדש יהיה לקריאה בלבד אם, ורק אם, המאגר הזה הוא לקריאה בלבד.

קריאה זו מקבילה slice(0, size)

פרמטרים
גוֹדֶל גודל המאגר החדש הזה
מחזיר
  • המאגר החדש
זורק
חריג טיעון לא חוקי אם ערכי אינדקס ו/או גודל אינם עוברים בדיקות אימות

Offset DataBuffer <T> תקציר ציבורי (אינדקס ארוך)

יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של תוכן מאגר זה, החל מהאינדקס הנתון.

האינדקס לא יכול להיות גדול מגודל המאגר הזה. שינויים בתוכן המאגר הזה יהיו גלויים במאגר החדש ולהיפך. המאגר החדש יהיה לקריאה בלבד אם, ורק אם, המאגר הזה הוא לקריאה בלבד.

קריאה זו מקבילה ל- slice(index, size() - index)

פרמטרים
מַדָד אינדקס של הערך הראשון של המאגר החדש שנוצר, לא יכול להיות גדול מ- size()
מחזיר
  • המאגר החדש
זורק
חריג טיעון לא חוקי אם אינדקס לא עובר בדיקות אימות

Public abstract DataBuffer <T> read (T[] dst)

קרא את ההפניות של האובייקטים במאגר זה לתוך מערך היעד.

שיטה זו מעבירה ערכים ממאגר זה למערך היעד הנתון. אם יש פחות ערכים במאגר מהנדרש כדי לספק את הבקשה, כלומר, אם dst.length > size() , אז לא מועברים ערכים ונזרק BufferUnderflowException.

אחרת, שיטה זו מעתיקה ערכי n = dst.length ממאגר זה למערך הנתון.

פרמטרים
dst המערך שאליו יש לכתוב ערכים
מחזיר
  • החיץ הזה
זורק
BufferUnderflowException אם אין מספיק ערכים להעתקה מהמאגר הזה

Public abstract DataBuffer <T> read (T[] dst, int offset, int length)

קרא את ההפניות של האובייקטים במאגר זה למערך היעד.

שיטה זו מעבירה ערכים ממאגר זה למערך היעד הנתון. אם יש פחות ערכים במאגר מהנדרש כדי לספק את הבקשה, כלומר, אם length > size() , אז לא מועברים ערכים ונזרק BufferUnderflowException.

אחרת, שיטה זו מעתיקה ערכי n = length מהמאגר הזה למערך הנתון החל מההיסט הנתון.

פרמטרים
dst המערך שאליו יש לכתוב ערכים
לְקַזֵז ההיסט בתוך המערך של הערך הראשון שייכתב; חייב להיות לא שלילי ולא גדול מ- dst.length
מֶשֶׁך המספר המרבי של ערכים שייכתב למערך הנתון; חייב להיות לא שלילי ולא גדול מ- dst.length - offset
מחזיר
  • החיץ הזה
זורק
BufferUnderflowException אם נותרו פחות מערכי אורך במאגר הזה
IndexOutOfBoundsException אם התנאים המוקדמים בפרמטרי ההיסט והאורך אינם מתקיימים

Public abstract DataBuffer <T> setObject (ערך T, אינדקס ארוך)

כותב את הערך הנתון למאגר הזה באינדקס הנתון. חשוב: השימוש בשיטה זו צריך להיות מוגבל למאגרים מסוגים לא פרימיטיביים או כאשר סוג הנתונים אינו ידוע באופן דטרמיניסטי על ידי המתקשר. בכל מקרה אחר, העדיפו את השימוש בגרסה הפרימיטיבית שלו שתשפר משמעותית את הביצועים (למשל IntDataBuffer.setInt(idx)

פרמטרים
עֵרֶך הערך שייכתב
מַדָד המדד שבו ייכתב הערך
מחזיר
  • החיץ הזה
זורק
IndexOutOfBoundsException אם האינדקס שלילי או לא קטן מגודל המאגר
ReadOnlyBufferException אם המאגר הזה הוא לקריאה בלבד

תקציר ציבורי בגודל ארוך ()

גודל המאגר, באלמנטים.

לדוגמה, במקרה של מאגר בתים, ערך זה שווה למספר בתים המאגר הזה יכול להחזיק. עבור מאגר שלם, הוא שווה למספר המספרים השלמים, לכן הגודל בבייטים של מאגר זה הוא size() * Integer.BYTES .

מחזיר
  • גודל המאגר

פרוסת DataBuffer <T> תקציר ציבורי (אינדקס ארוך, גודל ארוך)

יוצר מאגר חדש שהתוכן שלו הוא רצף משותף של תוכן מאגר זה, החל מהאינדקס הנתון ובגודל הנתון.

האינדקס בתוספת הגודל החדש לא יהיו גדולים מגודל המאגר הזה. שינויים בתוכן המאגר הזה יהיו גלויים במאגר החדש ולהיפך. המאגר החדש יהיה לקריאה בלבד אם, ורק אם, המאגר הזה הוא לקריאה בלבד.

פרמטרים
מַדָד אינדקס של הערך הראשון של המאגר החדש שנוצר
גוֹדֶל גודל המאגר החדש הזה, לא יכול להיות גדול מ- size()
מחזיר
  • המאגר החדש
זורק
חריג טיעון לא חוקי אם ערך הגודל לא יעבור בדיקות אימות

תקציר ציבורי DataBufferWindow <? מרחיב את חלון DataBuffer <T>> (גודל ארוך)

יוצר DataBufferWindow המספק תצוגה חלקית של מאגר זה.

לחלון שנוצר יש גודל קבוע והוא יכול "slide" לאורך המאגר הזה כדי לספק תצוגות שונות של הנתונים מבלי להקצות מופע חיץ חדש, כמו offset(long) עושה. זה משפר את הביצועים הכוללים כאשר פעולה זו חוזרת על עצמה לעתים קרובות. לְדוּגמָה: 

IntDataBuffer bufferA = DataBuffers.ofInts(1024);
 // ... init buffer data
 IntDataBuffer bufferB = DataBuffers.ofInts(1, 2, 3, 4);

 // Return the index of the first occurrence of bufferB in bufferA using a sliding window
 DataBufferWindow<IntDataBuffer> windowA = bufferA.window(4);
 for (int i = 0; i < bufferA.size() - bufferB.size(); ++i) {
     if (windowA.slideTo(i).buffer().equals(bufferB)) {
         return i;
     
 }
 }

האובייקט המוחזר הוא מצבי ואינו בטוח לחוט.

פרמטרים
גוֹדֶל גודל החלון
מחזיר
  • חלון חדש שמתחיל באינדקס 0 של מאגר זה
זורק
UnsupportedOperationException אם סוג זה של מאגר אינו תומך בחלונות מאגר

תקציר ציבורי של DataBuffer <T> כתיבה (T[] src)

כתוב את ההפניות של האובייקטים במערך המקור לתוך המאגר הזה.

שיטה זו מעבירה את הערכים במערך המקור הנתון למאגר הזה. אם יש יותר ערכים במערך המקור מאשר במאגר הזה, כלומר אם src.length > size() , אז לא מועברים ערכים ונזרק BufferOverflowException.

אחרת, שיטה זו מעתיקה ערכי n = src.length מהמערך הנתון.

פרמטרים
src מערך המקור שממנו יש לקרוא ערכים
מחזיר
  • החיץ הזה
זורק
BufferOverflowException אם אין מספיק מקום במאגר הזה עבור הערכים במערך המקור
ReadOnlyBufferException אם המאגר הזה הוא לקריאה בלבד

public abstract DataBuffer <T> כתיבה (T[] src, int offset, int length)

שיטת הצבת בכמות גדולה, באמצעות מערכי int.

שיטה זו מעבירה את הערכים במערך המקור הנתון למאגר הזה. אם יש יותר ערכים במערך המקור מאשר במאגר הזה, כלומר אם length > size() , אז לא מועברים ערכים ונזרק BufferOverflowException.

אחרת, שיטה זו מעתיקה ערכי n = length מהמערך הנתון למאגר זה, החל מההיסט הנתון.

פרמטרים
src מערך המקור שממנו יש לקרוא ערכים
לְקַזֵז ההיסט בתוך המערך של הערך הראשון שיש לקרוא; חייב להיות לא שלילי ולא גדול מ- src.length
מֶשֶׁך מספר הערכים שיש לקרוא מהמערך הנתון; חייב להיות לא שלילי ולא גדול מ- src.length - offset
מחזיר
  • החיץ הזה
זורק
BufferOverflowException אם אין מספיק מקום במאגר הזה עבור הערכים במערך המקור
IndexOutOfBoundsException אם התנאים המוקדמים בפרמטרי ההיסט והאורך אינם מתקיימים
ReadOnlyBufferException אם המאגר הזה הוא לקריאה בלבד