Innehållsförteckning
Trots att arbeta med Databaser Det är en mycket bra sak och det sparar oss mycket arbete när vi gör frågor och relaterar poster, det finns tillfällen då vi behöver generera filer, eftersom vi inte har en server Databas tillgänglig eller kanske för att vi inte behöver spara en post utan en icke -relaterad datamängd.Filhantering är ett område som många fortfarande ser som komplext eller kanske föråldrat, men detta är felaktigt, generering av filer är avgörande för utveckling av system och applikationer. En fil kan sträcka sig från att skapa en .Text med vissa rader i synnerhet, fram till generationen av stora .xml att vi kan definiera en konfiguration.
För att hantera allt som innebär att skapa en fil på ett system, Java räkna med klassen Fil i bibliotekspaketet för datainmatning och utmatningshantering java.io. Denna klass ger oss olika metoder som gör att vi kan utföra operationer som sträcker sig från skapa och ta bort filer, skapa kataloger, validera behörigheter etc..
Innan vi i praktiken ser hur vi kan använda klassen för att utföra filoperationer, måste vi förstå att de gör några av sina huvudsakliga metoder, med detta kommer vi att ha en teoretisk bas som vi kan gå till när vi presenteras för ett särskilt problem som kräver hantering av filer i våra program:
existerar ()Denna metod ger oss ett booleskt svar om förekomsten av en viss fil i en katalog som vi specificerar när vi anropar den, uppenbarligen returnerar den sant eller sant om filen hittas och falsk eller falsk om den inte är det.
getCanonicalPath ()Denna metod returnerar hela namnet inklusive filvägen, det är mycket viktigt att få den absoluta positionen för vår fil i systemet där vi kör vårt program.
hämta namn ()I motsats till föregående metod returnerar detta bara det relativa och korta namnet på filen, det vill säga utan att inkludera adressen eller mappen där den finns.
kan läsa ()Denna metod låter oss verifiera om vi har behörighet att läsa filen, det är mycket viktigt att validera om vi kan läsa en fil eller inte innan vi startar en operation med den, på så sätt kan vi minska undantag och spara systemresurser.
kan skriva ()Detta är en annan metod som hjälper oss att validera behörigheterna för filerna när vi använder den på en instans av klassen Fil meddelar oss om vi kan skriva motsvarande fil.
längd ()Denna metod är en av de mest användbara eftersom den tillåter oss att veta storleken på en fil, en viktig kontroll vid bearbetning.
isFile ()Slutligen tillåter denna metod oss att veta om det vi utvärderar är en fil eller en katalog, så vi vet om vi arbetar med den struktur vi vill ha.
De skapa en fil Det är en process genom vilken vi skriver inom systemet där vårt program körs. Det är skillnad mellan att skriva en fil och att skriva inuti en fil, den första berättar att vi genererar filen i systemet, men vi har inte nödvändigtvis lagt till innehållet i den; Å andra sidan berättar den andra att vi lägger till innehåll i en befintlig fil.
De kanske undrar varför vi vill ha en tom fil, en tom fil är inte värdelös, den kan vara en del av en större process inom ett program, till exempel skapar en metod filen och efter ett resultat av en process tar en annan metod hand om att lägga till data till den. Det kan också vara viktigt vid valideringar, där vi genererar tillfälliga filer för att indikera för programmet vilken fas av processen vi befinner oss i, etc.
Låt oss se nedan en liten kod där vi genererar en tom plattfil.
importera java.io. *; importera java.io.File; public class CreateFiles {public static void main (String [] argv) kastar IOException {if (argv.length == 0) {System.err.println ("Du måste ange ett namn efter parameter"); System.exit (1); } för (String filnamn: argv) {ny fil (filnamn) .createNewFile (); }}} Vi ser att det första vi gör är en import av klasserna av java.io för att kunna komma åt undantagshantering med IOException, sedan importerar vi klassen java.io.Fil vilket gör att vi kan manipulera filerna direkt.
Sedan skapar vi vår klass och i dess metod huvud Vi anger att det kommer att ta emot argument, vi gör detta för att dynamiskt ange namnen på filerna. Eftersom vi behöver ett namn är det vi gör en liten validering, som indikerar att om ett filnamn inte tas emot, ombeds det att placera det och programmet avslutas. Slutligen för varje mottaget argument kommer vi att skapa en ny fil, med det vi gör är en ny instans av klassen Fil och med metoden createNewFile () vi genererar filen i systemet.
Vi måste vara medvetna om att om vårt program inte har tillräckliga behörigheter för att skapa en fil i sin katalog kommer vi att få ett fel. Utan vidare, låt oss se hur vårt program ser ut när vi kör det på konsolen:
FÖRSTORA
En annan av de vanligaste operationerna när man arbetar med filer efter att ha skrivit och tagit bort är att byta namn, för detta i Java Vi måste följa en process som kan verka komplicerad, men som vi kommer att se i exemplet som kommer att följa med förklaringen är det något ganska lätt att förstå.
Hur man gör det?Byt namn på en fil i Java kräver två objekt av typ Fil, den första innehåller filen som vi vill byta namn på och den andra innehåller filens nya namn, när vi uppfyller dessa villkor måste vi kalla metoden renameTo () över det befintliga filobjektet och skicka det nya objektet med det nya namnet.
Låt oss se koden vi behöver för att utföra byte av namn på vår fil:
importera java.io. *; importera java.io.File; public class RenameFiles {public static void main (String [] argv) kastar IOException {File FirstObject = new File ("NewFile.txt"); Fil secondobject = ny fil ("FileWithNewName.txt"); FirstObject.renameTo (SecondObject); }} Vi importerar motsvarande klasser och paket och behåller samma som föregående exempel.
Inuti metoden main () vi ska skapa vårt första objekt och vi kommer att sätta namnet på filen som vi hade skapat i föregående exempel i det här fallet är det FileNew.txt. Sedan skapar vi ett andra objekt med det nya namnet vi vill ha för vår fil, i exemplet vi har valt FileWithNewName.txt.
Slutligen tillämpar vi det första objektet metoden renameTo () och som argument eller parameter passerar vi det andra objektet som har det nya namnet för vår fil. Låt oss se hur det ser ut på konsolen när vi kör vår kod:
FÖRSTORA
Slutligen kommer vi att se den andra operationen som är ganska vanlig när man arbetar med filer och som är att ta bort, det här är kanske en av de enklaste, eftersom vi bara behöver veta namnet på filen, bekräfta att den finns och sedan fortsätta att radera det använder metoden ta bort () där vi kommer att skicka namnet på filen i fråga. Låt oss se i följande kod hur vi uppnår detta:
importera java.io. *; importera java.io.File; public class DeleteFile {public static void main (String [] argv) {delete ('FileWithNewName.txt'); } public static void delete (String filenameDelete) {try {File file = new File (filenameDelete); om (! file.exists ()) {System.err.println ("filen" + filnamnDelete + "inte finns i den här katalogen"); lämna tillbaka; } om (file.delete ()) System.err.println ("** filen" + fileNameDelete + "har tagits bort **"); annars System.err.println ("Det gick inte att ta bort filen:" + filnamnDelete); } catch (SecurityException e) {System.err.println ("Det gick inte att ta bort filen:" + DeleteFileName + "(" + e.getMessage () + ")"); }}} Vi ser att detta program är lite mer omfattande än de tidigare, det beror på att vi har skapat en återanvändbar funktion För radering av filer, där vi först validerar att filen finns, fortsätter vi att radera den, här validerar vi att den verkligen har raderats, annars informerar vi användaren om att filen inte kunde tas bort från filsystemet.
I konsolen kan vi se hur vi lyckades utföra denna operation, för detta använder vi filen som vi hade bytt namn på i föregående exempel, så när vi gör en lista över innehållet i mappen kommer vi att se ändringen reflekteras:
FÖRSTORA
FÖRSTORA
